automa teste

Prévia do material em texto

Automação e 
Gerenciamento de Testes 
 
 
 
Aumentando a Produtividade 
com as Principais Soluções 
Open Source e Gratuitas 
 
 
 
 
 
 
Cristiano Caetano 
 
 
1
Prefácio...................................................................................................5 
Agradecimentos .......................................................................................7 
Introdução...............................................................................................8 
Proposta deste livro................................................................................11 
Considerações iniciais .............................................................................12 
Capítulo 1 • Gestão de defeitos ...............................................................14 
Mantis................................................................................................15 
Instalando e configurando ................................................................16 
Criando um novo projeto..................................................................17 
Registrando e modificando um bug ...................................................19 
Meus Bugs ......................................................................................22 
Sumário dos bugs ............................................................................23 
News ..............................................................................................24 
Change Log.....................................................................................25 
Documentação do projeto ................................................................25 
Configuração do Mantis ....................................................................26 
Capítulo 2 • Gestão de testes ..................................................................27 
TestLink .............................................................................................28 
Instalando e configurando ................................................................29 
Criando um novo projeto..................................................................30 
Adicionando requisitos .....................................................................31 
Adicionando test cases .....................................................................34 
Associando test cases aos requisitos..................................................38 
Associando keywords aos test cases..................................................39 
Criando test suites ...........................................................................41 
Associando níveis de prioridade a test suite .......................................44 
Associando usuários ao test suite ......................................................44 
Criando builds e milestones ..............................................................45 
Executando os Test Cases ................................................................46 
Capítulo 3 • Gestão de projetos ...............................................................49 
php-collab ..........................................................................................50 
Instalando e configurando ................................................................51 
Criando um novo projeto..................................................................52 
Adicionando tarefas .........................................................................55 
Visualizando o calendário do projeto .................................................56 
Listas de discussões.........................................................................57 
Adicionando arquivos ao projeto .......................................................59 
Bookmarks compartilhados ...............................................................61 
Adicionando clientes ........................................................................62 
Requisições de suporte.....................................................................65 
Relatórios........................................................................................66 
Capítulo 4 • Automação de testes funcionais e de aceitação.......................67 
Selenium............................................................................................68 
Selenium Core .................................................................................69 
 
2
Selenium IDE ..................................................................................73 
Selenium RC (Remote Control)..........................................................78 
Marathon ...........................................................................................83 
Criando um novo projeto..................................................................84 
Criando um script de teste................................................................87 
Criando um módulo reutilizável .........................................................90 
Executando os scripts de teste por meio do JUnit ...............................92 
Criando uma fixture .........................................................................93 
SoapUI...............................................................................................95 
Criando um novo projeto..................................................................96 
Criando um test case ..................................................................... 100 
Criando asserções.......................................................................... 102 
Depurando os Test Cases ............................................................... 104 
Adicionando novos Test Steps ao Test Case ..................................... 105 
Criando testes de desempenho e stress ........................................... 107 
Capítulo 5 • Automação de testes de performance .................................. 109 
JMeter ............................................................................................. 110 
Configurando um test plan ............................................................. 111 
Adicionando e configurando um thread group .................................. 112 
Gravando um teste por meio de um HTTP Proxy .............................. 114 
Adicionando asserções ................................................................... 117 
Adicionando um timer .................................................................... 120 
Adicionando listeners (relatórios) .................................................... 121 
Executando e visualizando os resultados.......................................... 123 
Monitorando a performance do servidor........................................... 126 
Microsoft WEB Application Stress........................................................ 131 
Gravando um teste por meio de um HTTP Proxy .............................. 132 
Executando e visualizando os resultados.......................................... 136 
Configurando o comportamento dos testes ...................................... 138 
Configurando Page Groups ............................................................. 139 
Configurando usuários para autenticação......................................... 141 
Capítulo 6 • Controle de versões............................................................ 142 
CVS ................................................................................................. 143 
TortoiseCVS .................................................................................. 146 
Repositório.................................................................................... 147 
Importação ................................................................................... 147 
Retirada dos arquivos do repositório................................................ 151 
Modificando os arquivos................................................................. 152 
Inspecionando as modificações ao longo do tempo........................... 154 
Configurando o TortoiseCVS ........................................................... 155 
Capítulo 7 • Ferramentas de apoio......................................................... 156 
Tail for Win32................................................................................... 157 
HeavyLoad ....................................................................................... 158 
Process Explorer ............................................................................... 159 
 
3
VMWARE.......................................................................................... 160 
Microsoft Pairwise Independent Combinatorial Testing ......................... 161 
Burp Suite ........................................................................................ 162 
Camstudio ........................................................................................ 163 
MWSnap .......................................................................................... 164 
WinMerge......................................................................................... 165 
Data Generator ................................................................................. 166 
Firebug ............................................................................................ 167 
Considerações Finais ............................................................................ 168 
Ferramentas similares não apresentadas neste livro............................. 168 
Repositórios de ferramentas Open Source........................................... 172 
Alternativas comerciais ...................................................................... 174 
Referências sobre teste de software ................................................... 178 
Sobre o autor ................................................................................... 179 
Bibliografia Recomendada ..................................................................... 180 
Bibliografia .......................................................................................... 182 
Índice Remissivo .................................................................................. 183 
 
 
 
 
 
 
 
 
 
 
 
4
Prefácio 
 
Caro Leitor, 
 
O grande escritor e poeta Carlos Drummond de Andrade disse uma vez que 
todas as vezes que se abre uma livraria deveríamos comemorar com festa, tal 
qual o nascimento de uma criança. Da mesma forma que quando nasce um 
livro, seja por qual mídia ou formato que ele venha, deveríamos comemorar 
com festa e grande orgulho. Um livro representa uma expressão viva de um 
conjunto de conhecimentos que se acumularam e que foi compartilhado. Este 
conhecimento pode ser um conto, uma história, um conhecimento técnico, ou 
até mesmo um pouco de sabedoria que todos nós aprendemos diariamente. 
Este livro é um reflexo da experiência profissional madura em Teste e 
Qualidade de Software vivida pelo autor, meu amigo Cristiano Caetano. 
 
Quando vemos os altos custos do processo de desenvolvimento subindo cada 
vez mais e se exigindo níveis de excelência cada vez maiores, percebe-se que 
a necessidade em se conhecer ferramentas que tenham custo zero se tornou 
uma exigência. 
 
A maioria das empresas usa, ou vão usar ainda, alguma ferramenta Open 
Source ou Gratuita. O Linux é um exemplo real disto e tem tomado cada vez 
mais espaço. Muitas grandes empresas têm aberto o código de seus produtos 
e optado por ter lucro através da venda de serviço associado à ferramenta, 
ao invés de "ganhar" puramente com a venda da ferramenta. É um modelo 
novo de negócio. É uma nova visão. É algo que veio pra ficar. Você pode até 
não gostar e evitar. Pode desconfiar, mas é impossível negar o que está aí. É 
uma nova transformação. Conclusão: Transforme-se ou você será 
transformado. Será transformado em um profissional que se "esqueceu" de 
se atualizar. Infelizmente, no mercado de trabalho, quem se esquece torna-
se um esquecido. 
 
Leve este livro para todos os lados e não tenha medo de perguntar ao 
Cristiano, ou de pesquisar nas referências citadas no livro. Este livro é, em 
essência, uma ferramenta de apoio para quem deseja usar soluções em 
Automação e Gerenciamento de Testes de Software. 
 
Quando o Cristiano me convidou em um primeiro instante para prefaciar o 
seu livro, relutei um pouco, talvez porque queria entender a "alma" do livro. 
Afinal sou escritor, e cada livro para mim é como um filho. Aceitei, e me 
orgulho do convite aceito, porque percebi a essência central deste livro: 
compartilhar com convicção honesta uma grande experiência na área de 
Testes e Qualidade de Software. Repito: compartilhar. Disseminar. Dividir. No 
 
5
caso aqui: dividir para conquistar a sua transformação no modo de ver como 
as soluções Open Source podem ser úteis no seu trabalho. Este livro é como 
um afilhado para mim, e como "padrinho" dei sugestões que foram 
aproveitadas de modo a aproximar você, caro Leitor, fazendo-o sentir-se em 
casa. 
 
Devido a limitações de tamanho do livro e por algumas questões de 
inviabilidade técnica não foi possível colocar "tudo de tudo" no que se refere 
a automação de testes. A cada dia surgem novas soluções, e algumas 
amadurecem como o caso do Testlink, usado mundialmente e suportado por 
um grupo forte de usuários, e outras tantas acabam não vingando. Por isso o 
Cristiano colocou as que ele considerou mais usadas ou mais maduras. Mas 
lembre-se: a única certeza é a mudança. Por mais que o livro seja também 
uma "foto", este também é uma ferramenta madura e extremamente útil, 
tendo um pouco de tudo tal qual um "canivete suíço". Essa é a proposta do 
Cristiano. Simples, prática e multiuso. 
 
O livro se divide em grandes áreas que vão ajudá-lo a tirar o máximo de 
proveito do conhecimento aqui colocado. Por exemplo, se você não desejar 
ler o livro de forma seqüencial, pode fazê-lo indo direto no conhecimento que 
você precisa. O livro tanto servirá como livro base como livro de referência. 
 
Muitos têm medo de compartilhar conhecimento, mas o Cristiano Caetano 
não teve medo de compartilhar o conhecimento aqui colocado, da mesma 
forma que não tive medo em escrever de forma transparente aqui. O maior 
conhecimento e aquele que é dividido e de preferência no menor espaço de 
tempo. O futuro ainda não foi escrito, e cada um escreve o seu. Este livro é 
uma ferramenta para lhe ajudar a escrever de forma positiva o seu futuro na 
área de Automação de Testes de Software. 
 
Caro Leitor, acredite em você e não tenha medo. Boa leitura. 
 
 
 
Leonardo Molinari 
Consultor de Qualidade de Software, Palestrante e Autor de diversos livros 
como "Testes de Software", "BTO - Otimização da Tecnologia do Negócio", 
"Gestão de Projetos" e "Gerência de Configuração". 
 
E-mail: lm7k@yahoo.com.br 
Blog: http://diariodaqualidade.blogspot.com/ 
site: http://br.geocities.com/lm7k/testes.html 
 
 
6
Agradecimentos 
 
 
Eu gostaria de agradecer todas as pessoas que direta ou indiretamente 
contribuíram para a realização desta obra. Estou muito grato pelas críticas, 
conselhos e sugestões dos revisores: Leonardo Molinari, Renan Sucupira, 
Daniel Cunha, José Papo, Cristiane Machado e Sagiane D’ávila. 
 
Um obrigado especial para os meus gestores na HP Invent. O apoio, 
compreensão e aquele “empurrãozinho” especial na hora certa foram 
essenciais para a finalização desta obra e de outras realizações na minha vida 
pessoal. Sem vocês, esse livro não seria possível: obrigado. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7
Introdução 
 
"If you don't have the right equipment for 
thejob, you just have to make it yourself" 
MacGyver 
 
“Coloque um rádio transistorizado próximo ao processador do computador 
em que o teste estiver rodando, sintonize aproximadamente na estação 975 
AM e você poderá literalmente escutar o zumbido do processador 
funcionando. Essa técnica é bastante interessante para você descobrir se o 
processador está realmente realizando algum processamento durante algum 
teste ou se nada está acontecendo. O cenário descrito no parágrafo anterior, 
apesar de representar uma situação extrema, é um ótimo exemplo de um 
testador altamente eficaz em ação. À medida que se queira executar os 
testes com maior eficiência, torna-se necessário estar familiarizado com a 
maior gama de ferramentas que possam vir a ajudar a execução dos testes, 
simular um componente de hardware ou software que não estiver disponível, 
observar o tráfego da rede, entre outros cenários. As situações são ilimitadas, 
tudo depende do tipo de aplicação que estiver sendo testada” 
 
O trecho apresentado acima é parte de um dos meus artigos mais 
conhecidos: “Os 7 hábitos dos Testadores Altamente Eficazes”1; e é o fio 
condutor deste livro. Após a publicação do artigo “Os 7 hábitos dos 
Testadores Altamente Eficazes” a idéia de criar um novo artigo apresentando 
quais eram as ferramentas que os testadores altamente eficazes 
normalmente usam ficou martelando na minha cabeça por semanas. Eu 
acabei me envolvendo com outros temas e escrevendo outros artigos até o 
dia em que eu comecei a ler o “Guide to the CSTE Common Body of 
Knowledge” do QAI. Em certo ponto do livro desta certificação de teste de 
software é abordado o tema “Utilização de ferramentas”. O livro afirma que 
apesar de não existir uma categorização amplamente difundida das 
ferramentas de teste, a experiência tem mostrado elas são normalmente 
agrupadas em 8 áreas distintas: 
 
1. Ferramentas de automação de testes de regressão; 
2. Ferramentas para gestão de defeitos; 
3. Ferramentas para testes de Performance/Estresse; 
4. Ferramentas manuais; 
5. Ferramentas de rastreabilidade; 
6. Ferramentas de cobertura de código; 
7. Ferramentas para gestão de testes; 
8. Ferramentas de apoio à execução dos testes; 
 
1 http://www.linhadecodigo.com.br/artigos.asp?id_ac=1083 
 
8
Naquele momento, entre riscos e rabiscos numa folha em branco o artigo 
ganhou forma. Uma das premissas básicas originais era de que somente 
ferramentas Open Source2 e gratuitas fariam parte do escopo. Entretanto, o 
escopo sofreu muitas modificações ao longo da sua história. O artigo que iria 
abordar apenas ferramentas utilizadas por testadores altamente eficazes, 
acabou abraçando ferramentas das áreas sugeridas pelo “Guide to the CSTE 
Common Body of Knowledge”, tais como ferramentas para gestão de 
defeitos, gestão de testes, automação de testes de regressão e assim por 
diante. Assim que finalizei o primeiro rascunho do MindMap contendo as 
áreas e ferramentas que seriam abordadas no artigo, ficou muito claro que 
não daria para apresentar tudo o que eu queria apenas num artigo; ficaria 
exageradamente superficial. 
 
Então surgiu a idéia do livro. Após uma pequena pesquisa, cheguei a 
conclusão de que o escopo deveria ser reduzido a fim de evitar que o livro 
levasse muito tempo para ser escrito e ficasse muito desatualizado (as 
ferramentas Open Source evoluem numa velocidade fantástica). Dessa forma 
eu tinha um escopo e um deadline definidos. As primeiras páginas deste livro 
foram escritas em dezembro de 2006 e, entre semanas extremamente 
produtivas e semanas sem nenhuma página escrita, as últimas páginas foram 
finalizadas em julho de 2007 (a última linha sendo escrita no último dia, mas 
dentro do prazo previsto). 
 
Mas não pensem que foi fácil. Como você poderá notar mais adiante no 
capítulo “Ferramentas similares não apresentadas neste livro”, o escopo 
original era bastante extenso e interessante. Foi duro ter que remover o 
Bugzilla, o XPlanner, o WEBLoad, entre outros do escopo. De qualquer forma, 
o escopo teve que ser redefinido tendo em mente as ferramentas realmente 
essenciais; outro ponto que pesou muito foi a facilidade de uso e o tamanho 
das comunidades apoiando e suportando estas ferramentas. Ferramentas 
com grandes comunidades e liberações freqüentes foram privilegiadas em 
relação às outras. 
 
De qualquer forma, tive o cuidado de manter as ferramentas do escopo 
original para que o leitor possa explorar as outras alternativas não 
apresentadas neste livro. Considere isso, um atalho onde o joio já foi 
separado do trigo para você. 
 
No entanto, por mais abrangente que sejam as categorias e ferramentas 
apresentadas neste livro, seria ingênuo pensar que ele ofereceria soluções 
que atendessem a necessidade de todos os leitores. Pensando neste cenário, 
fiz uma pesquisa extensa cujo resultado é uma lista detalhada com os 
maiores e melhores repositórios de ferramentas Open Source do mundo, a 
 
2 http://en.wikipedia.org/wiki/Open_source 
 
9
fim de permitir que você leitor, possa escolher a solução que atenda a sua 
necessidade. 
 
E para você, que estava prestes a perguntar sobre as ferramentas 
comerciais. –Sim, elas estão listadas no capítulo “Alternativas comerciais”. 
Para cada categoria apresentada neste livro, foram listadas algumas das 
soluções comerciais existentes. Não foram esgotadas as opções, mas já é um 
bom ponto de partida. 
 
Ah, e para leitor que quiser aprender ou aprimorar os seus conhecimentos 
em teste de software, o capítulo “Referências sobre teste de software” 
apresenta uma listagem dos livros nacionais mais importantes da atualidade 
sobre esse tema. 
 
Este livro foi escrito com muito cuidado e é fundamentado na experiência e 
na pesquisa realizada pelo autor. No entanto, podem existir erros, 
inconsistências ou omissões que não foram percebidas durante as revisões. 
Sinta-se à vontade para entrar em contato com o autor para que as devidas 
correções sejam realizadas. 
 
Boa leitura, 
 
Cristiano Caetano 
c_caetano@hotmail.com 
http://softwarequality.spaces.live.com/ 
 
 
 
Julho/2007 
1a Edição v2.0 (atualizada em Outubro/2007) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
10
Proposta deste livro 
 
A proposta deste livro é apresentar as ferramentas Open Source e gratuitas 
essenciais para a gestão e automação de testes de software, sem no entanto, 
esgotar o assunto. O livro tem o propósito de apresentar um catálogo das 
melhores opções disponíveis atualmente e os seus principais recursos. Porém, 
não faz parte do escopo deste livro, detalhar todos os recursos existentes, 
todas as possibilidades de configuração ou tornar os leitores especialistas nas 
ferramentas apresentadas. 
 
Dessa forma, o objetivo principal deste livro é fornecer informações e 
subsídios a fim de que o leitor seja capaz de utilizar os conhecimentos 
adquiridos para aprofundar-se no assunto e escolher a solução que melhor 
atenda a sua necessidade. 
 
Por último, devemos lembrar que este livro não foi escrito para substituir o 
manual de nenhuma das ferramentas apresentadas. Dúvidas específicas 
devem ser sanadas por meio dos manuais ou por meio dos fóruns de 
discussões das comunidades que suportam as ferramentas. 
 
Também não faz parte do escopo deste livro apresentar a teoria ou técnicas 
de teste de software. O capítulo “Referências sobre teste de software” 
apresenta uma listagem com os livros nacionais mais importantes da 
atualidade sobre esse tema. 
 
Este livro será unicamente comercializado por meio eletrônico (e-book). Esta 
foi uma decisão pessoal do autor para viabilizar a venda do livro por um 
preço justo a fim de permitir que todas as pessoas interessadas possam 
comprá-lo. Também foi decisão do autor não utilizar nenhum tipo de 
mecanismode segurança ou senha neste livro com base na premissa de que 
o livro tem um preço justo e que qualquer um pode pagar por ele. 
 
É com base nessa relação de confiança que você está neste momento lendo 
estas linhas por um preço justo. Mas, no entanto, se por algum motivo este 
livro está sendo útil para você, mas você não pagou por ele, peço que você 
prestigie o autor e compre o livro no endereço abaixo para que o autor possa 
escrever outros livros com preços acessíveis tanto para você quanto para 
outras pessoas interessadas em teste de software: 
 
http://www.linhadecodigo.com/EBook.aspx?id=2951 
 
 
 
 
11
Considerações iniciais 
 
Desenvolver software de qualidade não é mais um requinte para poucos, 
transformou-se num fator de competitividade num mercado cada vez mais 
exigente. O filósofo Nietzsche, no século passado, alertava: "Com o aumento 
da competição, a qualidade se torna mera propaganda. Vence aquele que 
melhor engana". 
 
Essa receita é muito simples e fácil de seguir, todavia, quem tomar esse tipo 
de postura estará fadado ao fracasso. Nos dias de hoje, a qualidade tornou-
se requisito imprescindível para garantir a sobrevida de um software no 
mercado. 
 
Podemos concluir que as empresas mais competitivas são as empresas que 
trabalham sob a ótica da melhoria contínua dos processos para aumentar a 
qualidade do processo de desenvolvimento e, conseqüentemente, aumentar 
a qualidade do produto final. 
 
Neste contexto, devemos destacar adoção crescente de ferramentas para dar 
suporte ao processo de melhoria contínua. Estas ferramentas servem para 
dar suporte a todas as atividades relacionadas ao ciclo de vida de 
desenvolvimento de software: da concepção à implantação. 
 
Como mencionamos anteriormente, a proposta deste livro é apresentar as 
ferramentas Open Source e gratuitas essenciais para a gestão e automação 
de testes de software. Dessa forma, a figura abaixo apresenta a relevância 
de cada tipo de ferramenta apresentada neste livro em relação às fases de 
um ciclo de vida de desenvolvimento de software: 
 
 
 
 
 
 
12
Neste livro serão apresentadas e sugeridas diversas ferramentas Open Source 
e gratuitas. Para o autor, é considerado Open Source Software 3 (OSS) todo e 
qualquer software que permita simultaneamente: 
 
ƒ A sua utilização para qualquer fim e sem restrições; 
ƒ A distribuição de cópias sem restrições; 
ƒ O acesso ao seu código fonte e o estudo do seu funcionamento; 
ƒ A sua adaptação às necessidades de cada um; 
ƒ A possibilidade de disponibilizar a terceiros quaisquer alterações 
introduzidas; 
 
Está fora do escopo deste livro, comparar e debater as vantagens da 
utilização de ferramentas Open Source em relação a ferramentas comerciais4. 
No entanto, devemos destacar que a principal vantagem na adoção de 
ferramentas Open Source é a economia na aquisição de licenças, uma vez 
que estas ferramentas são distribuídas gratuitamente. Por outro lado, existe o 
custo de formação, suporte e manutenção. Neste caso, cada organização 
deve utilizar os seus próprios critérios para calcular o ROI (Return of 
Investment) e o TCO (Total Cost of Ownership) na ocasião da adoção de uma 
ferramenta Open Source. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3 http://www.opensource.org/ 
4 http://cio.uol.com.br/estrategias/2005/08/22/idgnoticia.2005-08-22.4315880495 
 
13
Capítulo 1 • Gestão de defeitos 
 
A gestão de defeitos é uma das atividades primordiais de um processo de 
teste de software. Por meio da gestão de defeitos podemos acompanhar a 
qualidade do software em teste com base nos defeitos cadastrados pelos 
testadores ao longo de um ciclo de teste. Com base nesses dados, podemos 
identificar áreas problemáticas da aplicação onde os riscos são maiores e 
planejar atividades preventivas. 
 
A gestão de defeitos pode ser implementada por meio de ferramentas 
automatizadas (bug tracking system). Estas ferramentas devem oferecer um 
repositório central e padronizado onde todos os membros do time poderão 
cadastrar os defeitos, acompanhar o ciclo de vida destes defeitos e emitir 
relatórios de gestão. 
 
Na figura abaixo, você poderá visualizar os principais passos de um processo 
de gestão de defeitos formal e os papéis associados: 
 
 
 
Na tabela abaixo você poderá ver a ferramenta que será apresentada nas 
próximas seções: 
 
Mantis 
 
http://www.mantisbt.org/ 
 
14
Mantis 
 
O Mantis5 é uma ferramenta Open Source cujo principal objetivo é registrar e 
acompanhar os bugs encontrados em um projeto, desde o seu nascimento 
até o seu fechamento. Neste cenário, o ciclo de vida gerenciado pelo Mantis 
inicia-se quando um bug é registrado; as fases seguintes são empregadas 
para a confirmação, correção, revisão e o fechamento do bug. Cada bug 
recebe um número seqüencial único a fim de identificá-lo durante as 
operações de consulta, relatórios e modificações. Por outro lado, diversas 
informações são agregadas ao bug durante as fases que compõem o seu 
ciclo de vida, como por exemplo, status, prioridade, severidade, comentários, 
anexos, etc. 
 
Entre as diversas funcionalidades oferecidas pelo Mantis, devemos destacar 
as seguintes: 
 
ƒ Pode ser executado em qualquer plataforma que suportar PHP/Apache 
(Windows, Linux, Mac, Solaris, AS400/i5, etc); 
ƒ Suporta vários bancos de dados (MySQL, MS SQL, PostgreSQL); 
ƒ Suporta múltiplos mecanismos de autenticação (Interna, LDAP, HTTP 
Basic, Active Directory); 
ƒ Traduzido em 68 línguas diferentes (incluindo "portuguese_brazil"); 
ƒ Criação ilimitada de projetos e relatos de defeitos; 
ƒ Controle de acesso e níveis de permissões para os usuários; 
ƒ Ciclo de vida dos defeitos (worflow) personalizável; 
ƒ Gerador interno de relatórios e gráficos (possibilidade para exportar os 
dados nos formatos CSV, Excel e Word); 
ƒ Mecanismo para a criação de campos personalizáveis (custom fields); 
ƒ Notificações por email automáticas ou por meio de RSS Feeds; 
ƒ Integração com ferramentas de controle de versões (Subversion e 
CVS); 
ƒ Interface Webservice (SOAP) para integração com outras ferramentas; 
ƒ MantisWAP – Suporte a dispositivos móveis (funcionalidade paga); 
 
 
 
 
 
 
 
 
 
5 http://www.mantisbt.org/ (os exemplos deste livro são apresentados com a versão 1.0.5) 
 
15
Instalando e configurando 
 
Para instalar o Mantis, você deverá seguir os seguintes passos (a título de 
exemplo estamos sugerindo a utilização do XAMMP a fim de satisfazer os 
softwares requeridos para a utilização do Mantis (Apache, MySQL, PHP)). 
 
1. Faça o download do XAMMP6. 
2. Instale e inicialize o XAMMP conforme a orientação do manual ou 
descompacte o arquivo zip em alguma pasta no seu computador. 
3. Após instalado, configure um password para o usuário root do Mysql 
usando um dos métodos sugeridos no site do XAMMP7. 
4. Faça o download do Mantis. 
5. Descompacte o arquivo zip na pasta htdocs do XAMMP (ex: c:\xampp-
win32-1.6.2\xampp\htdocs\mantis_1.0.5). 
6. Abra o seu navegador e acesse o seguinte endereço: 
(http://localhost/mantis_1.0.5/). 
7. Na janela Pre-Installation Check, preencha os campos username com 
'root' e o campo password com a senha configurada no passo 3. 
8. Deixe os valores default nos demais campos. 
9. Pressione o botão Install/Upgrade Database. 
10. Abra o seu navegador e acesse o seguinte endereço: 
(http://localhost/mantis_1.0.5/login_page.php). 
11. Faça o login com o usuário padrão (administrator/root). Lembre-se de 
mudar a senha deste usuário. 
 
Caso você prefira utilizar esta ferramenta com todos os textos traduzidos 
para a língua portuguesa, então siga os passos descritos abaixo: 
 
1. Faça o login normalmente com o seu usuário esenha. 
2. Clique no menu “My Account” e então selecione a opção 
“Preferences”. 
3. No campo Language selecione a opção "portuguese_brazil". 
4. Pressione o botão "Update Prefs". 
 
 
 
 
 
 
 
 
 
6 http://www.apachefriends.org/en/xampp.html 
7 http://www.apachefriends.org/pt_br/faq-xampp-windows.html 
 
16
Criando um novo projeto 
 
Tão logo o Mantis seja instalado e configurado, a sua primeira ação deverá 
ser cadastrar um novo projeto para que seja possível cadastrar bugs e utilizar 
as demais funcionalidades. Para tal tarefa, você deverá clicar no menu 
“Manage” e então selecionar a opção “Manage Projects”. A página “Add 
Project” deverá ser exibida, conforme o exemplo apresentado na Figura 1. 
 
 
Figura 1: Criando um novo projeto no Mantis 
 
Nesta página você poderá fornecer diversas informações sobre o projeto, 
como por exemplo: o Nome do projeto, Status, Descrição do projeto entre 
outras informações. Uma vez que o projeto for cadastrado, você poderá 
selecioná-lo na lista de projetos existentes e inserir informações adicionais, 
tais como: SubProjetos, Categorias, Versões, Campos Personalizados, 
 
17
Usuários do projeto, entre outras informações conforme o exemplo 
apresentado na Figura 2. 
 
 
Figura 2: Configurando um projeto no Mantis 
 
 
 
 
 
 
 
 
 
 
18
Registrando e modificando um bug 
 
Para registrar (cadastrar) um bug no Mantis, você deverá clicar no menu 
“Report Issue”. A página “Enter Report Details” deverá ser exibida, como 
pode ser visto na Figura 3. Nesta página você deverá preencher os campos 
de acordo com o comportamento do bug encontrado. Se for necessário você 
poderá anexar alguma imagem ou arquivo para auxiliar o entendimento e 
evidenciar a existência do bug. O Mantis oferece também a opção de registro 
de bugs por meio de uma página avançada “Advanced Report”. A página 
“Advanced Report” exibe novos campos de preenchimento. Esta página é 
usada normalmente por usuários mais experientes que conseguem fornecer 
mais detalhes sobre o bug encontrado. 
 
 
Figura 3: Registrando um bug no Mantis 
 
Se for necessário você poderá ver a lista dos bugs existentes. Para tal tarefa, 
você deverá clicar no menu “View Issues”. A página “Viewing Issues” deverá 
ser exibida, como pode ser visto na Figura 4. Esta página, por default, lista 
todos os bugs abertos. No entanto, você poderá configurar filtros específicos 
 
19
conforme a sua necessidade com base nos campos de filtragem exibidos na 
parte superior desta página. O Mantis também permite que você salve o filtro 
para posterior utilização. 
 
 
Figura 4: Visualizando os bugs abertos 
 
É importante ressaltar que os bugs listados são apresentados em diferentes 
cores. Cada cor significa o status do bug conforme a legenda apresentada na 
parte inferior desta página (Figura 4) Você poderá clicar sobre qualquer bug 
da lista a fim de abrir a página “Viewing Issue” e modificar qualquer 
informação relacionada ao bug, como pode se visto no exemplo apresentado 
na Figura 5. 
 
 
20
 
Figura 5: Modificando um bug 
Uma vez dentro desta página, além de modificar as informações do bug, você 
poderá criar uma associação de relacionamento com outros bugs (relacionado 
a, filho de, pai de, etc) e também poderá selecionar a opção para monitorar o 
bug e receber um e-mail sempre que alguma informação for modificada. 
 
 
 
 
 
 
 
 
 
 
21
Meus Bugs 
 
O Mantis oferece uma página onde você poderá visualizar de forma resumida 
e consolidada todos os bugs. Para visualizar esta página, você deverá clicar 
no menu “My View”. Basicamente, esta página exibe os bugs registrados, 
atribuídos e monitorados por você. Além dessas informações, você poderá 
também visualizar os bugs recentemente modificados, bugs que não foram 
atribuídos e assim por diante, como pode visto no exemplo apresentado na 
Figura 6. De qualquer maneira, caso seja necessário, você poderá modificar 
os filtros default usados para exibir as informações nesta página por meio do 
link “[^]” existente em cada seção. 
 
 
Figura 6: Meus bugs 
 
 
 
 
 
22
Sumário dos bugs 
 
O Mantis oferece uma página onde você poderá visualizar o sumário de todos 
os bugs registrados. Para tal tarefa, você deverá clicar no menu “Summary”. 
Nesta página, você poderá visualizar o sumário dos bugs, gerar relatórios e 
gráficos com estatísticas, como pode ser visto no exemplo apresentado na 
Figura 7. 
 
 
Figura 7: Sumário dos bugs 
 
 
 
 
 
 
23
News 
 
O Mantis também oferece uma funcionalidade para a divulgação de notícias 
“News”. Por meio desta funcionalidade, você poderá registrar qualquer 
novidade ou aviso aos demais usuários do Mantis. Para tal tarefa, você 
deverá clicar no menu “News”. A página “Add News” deverá ser exibida, 
como pode ser visto na Figura 8. A notícia registrada poderá ser vista na 
página principal do Mantis. 
 
 
Figura 8: Registrando novidades e avisos 
 
 
 
 
 
 
24
Change Log 
 
Por meio do Change Log, você poderá ver todas as correções associadas a 
um determinado release (versão). Para visualizar o Change Log, você deverá 
clicar no menu “Change Log”, como pode ser visto no exemplo apresentado 
na Figura 9. 
 
 
Figura 9: Change Log 
Documentação do projeto 
 
Outra funcionalidade interessante é a possibilidade de adicionar a 
documentação do projeto no Mantis. Para realizar tal tarefa, você deverá 
clicar no menu “Docs” e fazer o upload dos documentos, como pode ser visto 
no exemplo apresentado na Figura 10. 
 
 
Figura 10: Documentação do projeto 
 
 
 
 
25
Configuração do Mantis 
 
O Mantis oferece uma série de páginas de configurações que você poderá 
utilizar para realizar customizações a fim de atender as suas necessidades. 
Para tal tarefa, você deverá clicar no menu “Manage”. Basicamente, esta 
página exibe as diversas áreas que você poderá realizar algum tipo de 
customização tais como: criação de campos personalizados, gestão de 
usuários, configuração de workflows, notificação por email, entre outros 
(como pode ser observado no exemplo apresentado na Figura 11). 
 
 
Figura 11: Configurando o Mantis 
 
 
 
 
 
 
 
 
 
26
Capítulo 2 • Gestão de testes 
 
A gestão de testes é o coração de um processo de teste de software. A 
gestão de testes é importante para o planejamento e controle das atividades 
de um projeto de teste. 
 
A gestão de testes pode ser implementada por meio de ferramentas 
automatizadas (test management system). Estas ferramentas devem oferecer 
um repositório central e padronizado onde os líderes de testes poderão criar 
suites com casos de testes, atribuir os casos de testes aos testadores, 
acompanhar o status da execução dos testes e emitir os relatórios com 
métricas e estatísticas. 
 
Na figura abaixo, você poderá visualizar os principais passos de um processo 
de gestão de testes formal e os papéis associados: 
 
 
 
Na tabela abaixo você poderá ver a ferramenta que será apresentada nas 
próximas seções: 
 
TestLink 
 
http://www.teamst.org/ 
 
27
TestLink 
 
O TestLink8 é uma aplicação Open Source cujo principal objetivo é gerenciar 
as atividades de testes de um projeto. Por meio do TestLink você poderá criar 
Test Cases e organizá-los em Test Suites. 
 
Você também poderá associar um conjunto de Test Cases a um testador e 
acompanhar os resultados da execução dos testes, assim como, gerar 
relatórios com diversas métricas para o acompanhamento da execução dos 
testes. 
 
O TestLink oferece um recurso para que você possa registrar e organizar os 
requisitos do projeto, assim como, associar os Test Cases aos requisitos. 
Dessa forma, você poderá garantiro rastreamento entre os requisitos e os 
Test Cases por meio de uma matriz de rastreabilidade. 
 
Adicionalmente, o TestLink permite a integração com Mantis. Por meio dessa 
integração, quando um Test Case falhar, você conseguirá associar os bugs 
cadastrados no Mantis a este Test Case. 
 
Entre as diversas funcionalidades oferecidas pelo TestLink, devemos destacar 
as seguintes: 
 
ƒ Pode ser executado em qualquer plataforma que suportar 
PHP/Apache/Mysql (Windows, Linux, Mac, Solaris, AS400/i5, etc); 
ƒ Traduzido em várias línguas diferentes (incluindo "Brazil Portuguese"); 
ƒ Controle de acesso e níveis de permissões por papéis (Líder, Testador, 
etc); 
ƒ Os casos de testes são organizados hierarquicamente em suítes; 
ƒ Os casos de testes podem ser classificados por palavras-chave 
"keyword" para facilitar a pesquisa e organização; 
ƒ Criação ilimitada de projetos e casos de testes; 
ƒ Os ciclos de testes podem ser priorizados e atribuídos aos testadores; 
ƒ Gerador interno de relatórios e gráficos (possibilidade para exportar os 
dados nos formatos CSV, Excel e Word); 
ƒ Integração com ferramentas de gestão de defeitos (Bugzilla, Mantis, 
Jira); 
 
 
 
 
 
8 http://www.teamst.org/ (os exemplos deste livro são apresentados com a versão 1.6.2) 
 
28
Instalando e configurando 
 
Para instalar o TestLink, você deverá seguir os seguintes passos (a título de 
exemplo estamos sugerindo a utilização do XAMMP a fim de satisfazer os 
softwares requeridos para a utilização do TestLink (Apache, MySQL, PHP)). 
 
1. Faça o download do XAMMP9. 
2. Instale e inicialize o XAMMP conforme a orientação do manual ou 
descompacte o arquivo zip em alguma pasta no seu computador. 
3. Após instalado, configure um password para o usuário root do Mysql 
usando um dos métodos sugeridos no site do XAMMP10. 
4. Faça o download do TestLink. 
5. Descompacte o arquivo zip na pasta htdocs do XAMMP (ex: c:\xampp-
win32-1.6.2\xampp\htdocs\testlink-1.6.2). 
6. Abra o seu navegador e acesse o seguinte endereço: (http://localhost/ 
testlink-1.6.2/install/index.php). 
7. Na janela de instalação, selecione a opção New installation. 
8. Na janela TestLink Setup, preencha os campos login com 'root' e o 
campo password com a senha configurada no passo 3. 
9. Deixe os valores default nos demais campos. 
10. Pressione o botão Setup TestLink. 
11. Abra o seu navegador e acesse o seguinte endereço: 
(http://localhost/testlink-1.6.2/login.php). 
12. Faça o login com o usuário padrão (admin/admin). Lembre-se de 
mudar a senha deste usuário. 
 
Caso você prefira utilizar esta ferramenta com todos os textos traduzidos 
para a língua portuguesa, então siga os passos descritos abaixo: 
 
1. Faça o login normalmente com o seu usuário e senha. 
2. Clique no menu “Personal”. 
3. No campo Locale selecione a opção "Portuguese (Brazil)". 
4. Pressione o Botão "Update". 
 
 
 
 
 
 
 
 
 
9 http://www.apachefriends.org/en/xampp.html 
10 http://www.apachefriends.org/pt_br/faq-xampp-windows.html 
 
29
Criando um novo projeto 
 
Assim que o TestLink for instalado e configurado, a sua primeira ação deverá 
ser criar um novo produto (projeto). Para tal tarefa, você deverá ir para a 
seção “Product Management” e então clicar no menu “Create New Products”. 
A página “Product Management” deverá ser exibida, conforme o exemplo 
apresentado na Figura 12. 
 
 
Figura 12: Criando um novo projeto no TestLInk 
 
É importante ressaltar que durante a criação do projeto, você poderá 
desabilitar o recurso de gerenciamento de requisitos oferecido pelo TestLink, 
caso você utilize alguma outra ferramenta para este fim. Além disso, você 
poderá associar uma cor ao projeto criado. Dessa forma, o fundo das páginas 
sempre serão da mesma cor que foi associada ao projeto neste passo. 
 
 
 
 
 
 
 
 
30
Adicionando requisitos 
 
Assim que o projeto for criado, o próximo passo é a criação dos requisitos 
(caso você tenha habilitado o recurso de gerenciamento de requisitos). 
Primeiro, você deverá adicionar uma Especificação de Requisito. Para realizar 
tal tarefa, vá para a seção “Requirements” e então clique no menu 
“Requirement Specification”. A página “Requirement Specification” deverá ser 
exibida, conforme o exemplo apresentado na Figura 13. É importante 
ressaltar que segundo a organização do TestLink, cada requisito deve ser 
associado a uma Especificação de Requisito, que representa a grosso modo 
um agrupador de requisitos semelhantes (algo como uma suíte ou seção de 
requisitos), como pode ser visto no modelo apresentado na Figura 14. 
 
 
Figura 13: Adicionando uma especificação de requisito 
 
31
 
Figura 14: Relacionamento entre os componentes do TestLink 
 
Tão logo a Especificação de Requisito seja criada, você deverá clicar sobre 
ela. A página “Edit Requirement Specification” deverá ser exibida, conforme o 
exemplo apresentado na Figura 15. 
 
 
Figura 15: Edição das especificações de requisitos 
 
 
 
32
Nesta página você poderá importar os requisitos por meio de um arquivo 
externo (*.CSV) ou adicionar o requisito manualmente. Observe ainda que, 
nesta página você poderá também visualizar a lista de requisitos existentes, 
assim como, gerar um relatório (por meio do botão “Analyze”) que demonstra 
um sumário dos requisitos cobertos e os não cobertos por testes. 
 
Para adicionar um requisito manualmente, você deverá clicar no botão 
“Create New REQ”. A página “Create a new Requirement” deverá ser exibida, 
conforme o exemplo apresentado na Figura 16. Convém lembrar, aliás, que 
durante a criação do requisito, você poderá identificar no campo “Status” se 
o requisito é testável ou não. 
 
 
Figura 16: Criando um novo requisito 
 
 
 
 
 
 
 
33
Adicionando test cases 
 
Assumindo que os requisitos já foram criados, o próximo passo deve ser a 
criação dos Test Cases. Em primeiro lugar, no entanto, você deverá criar uma 
Especificação de Teste. Para tal tarefa, clique no menu “Specification”. A 
página “Test Specification” deverá ser exibida, conforme o exemplo 
apresentado na Figura 17. Nesta página clique no botão “New Component” 
para criar um novo componente. 
 
 
Figura 17: Criando um novo Componente 
 
De forma similar aos requisitos, a Especificação de Teste deverá obedecer a 
uma organização hierárquica definida pelo TestLink. Nessa condição, segundo 
a hierarquia do TestLink, cada Especificação de Teste é composta por um ou 
mais Componentes, que por sua vez pode ter uma ou mais Categorias. Cada 
Categoria agrupa um ou mais Test Cases, como pode ser visto no modelo 
apresentado na Figura 18. 
 
34
 
Figura 18: Elementos de uma Configuração de Teste 
 
Uma vez que o Componente for criado, você deverá selecioná-lo na lista dos 
componentes disponíveis e clicar no botão “New Category”. A página “Create 
Category” deverá ser exibida, conforme o exemplo apresentado na Figura 19. 
 
 
Figura 19: Criando uma nova Categoria 
 
 
 
 
 
 
 
35
Finalmente, uma vez que a Categoria for criada, você deverá selecioná-la na 
lista de categorias a fim de criar um novo Test Case. Nesta página você 
poderá importar os Test Cases por meio de um arquivo externo (*.CSV) ou 
criar o Test Case manualmente. Para tal tarefa, você deverá clicar no botão 
“Create Test Cases”. A página “Create Test Case” deverá ser exibida, 
conforme o exemplo apresentado na Figura 20. 
 
 
Figura 20: Criando um novo Test Case 
 
 
 
36
O TestLink também permite a impressão dos Test Cases de uma Categoria ou 
Componente. Para realizar tal tarefa, você deverá ir para a seção “Test 
Specification” e então clicar no menu “Print Test Cases”. A página “PrintTest 
Case Specification” deverá ser exibida, conforme o exemplo apresentado na 
Figura 21. Nesta página você deverá selecionar a Categoria ou Componente 
que você deseja imprimir e configurar as opções de impressão na seção 
“Print Options”. 
 
 
Figura 21: Imprimindo Test Cases 
 
 
 
 
37
Associando test cases aos requisitos 
 
Conforme discutido anteriormente, o TestLink permite que você possa 
associar os Test Cases aos requisitos. Dessa forma, você poderá garantir o 
rastreamento entre os requisitos e os Test Cases por meio de uma matriz de 
rastreabilidade. Para realizar tal tarefa, você deverá ir para a seção 
“Requirements” e então clicar no menu “Assign Requirements”. A página 
“Assign Requirements to Test Case” deverá ser exibida, conforme o exemplo 
apresentado na Figura 22. Nesta página você deverá selecionar o Test Case 
desejado, depois selecionar os requisitos disponíveis e, por último, associar o 
Test Case aos requisitos (por meio do botão “Assign”). 
 
 
Figura 22: Associando test cases aos requisitos 
 
 
 
 
 
38
Associando keywords aos test cases 
 
O TestLink permite que uma keyword (palavra-chave) seja associada aos 
Test Cases. As keywords facilitam a realização de pesquisas ou filtros dos 
Test Cases disponíveis. Para criar uma Keyword, você deverá ir para a seção 
“Keywords” e então clicar no menu “Create Keywords”. A página “Enter New 
Keyword” deverá ser exibida, conforme o exemplo apresentado na Figura 23. 
 
 
Figura 23: Criando keywords 
 
Tão logo as keywords sejam criadas, você poderá associa-las aos Test Cases. 
Para realizar tal tarefa, você deverá ir para a seção “Keywords” e então clicar 
no menu “Assign Keywords”. Uma vez dentro desta página, você deverá 
selecionar o Test Case desejado. A página “Assign Keywords” deverá ser 
exibida, conforme o exemplo apresentado na Figura 24. Nesta página você 
deverá selecionar a keyword desejada e, por último, associa-la ao Test Case 
(por meio do botão “Assign”). 
 
 
39
 
Figura 24: Associando keywords 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
40
Criando test suites 
 
Você poderá criar Test Suites para agrupar os Test Cases por similaridade. 
Para criar uma Test Suite, você deverá ir para a seção “Test Suite 
Management” e então clicar no menu “Create Test Suite”. A página “New 
Test Suite” deverá ser exibida, conforme o exemplo apresentado na Figura 
25. Você poderá criar uma Test Suite baseada em outra já existente. Além 
disso, durante a criação da Test Suite você deverá informar se deseja 
controlar a permissão de acesso (dessa forma, você poderá determinar quais 
usuários podem visualizar e executar os testes desta Test Suite). 
 
 
Figura 25: Criando test suites 
 
Uma vez que a primeira Test Suite for criada, um novo conjunto de menus e 
opções será exibido na área esquerda da página principal do TestLink. A 
maioria dessas novas opções serve para o gerenciamento da Test Suite, 
execução dos Test Cases e geração de relatórios, como pode ser visto no 
exemplo apresentado na Figura 26. É preciso lembrar que você deve 
selecionar a Test Suite (seta vermelha da Figura 26) antes de começar a 
realizar qualquer operação para evitar modificações na Test Suite errada. 
 
 
41
 
Figura 26: Gerenciamento das Test Suites 
 
Por último, você deverá associar os Test Cases a Test Suite recém criada. 
Para tal tarefa, você deverá selecionar a Test Suite desejada, conforme 
orientado no parágrafo anterior. Em seguida, vá para a seção “Test Case 
Suite” e então clique no menu “Add Test Cases”. A página “Add Test Cases to 
the Test Suite” deverá ser exibida, conforme o exemplo apresentado na 
Figura 27. 
 
 
42
 
Figura 27: Associando Test Cases a Test Suite 
 
Nesta página você deverá selecionar o Test Case desejado (com base no 
Componente ou Categoria selecionada) e associar ao Test Suite por meio do 
botão “Add selected Test Cases”. É importante lembrar que você poderá 
utilizar as keywords para filtrar os Test Cases conforme a sua necessidade. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
43
Associando níveis de prioridade a test suite 
 
Você também poderá associar níveis de prioridade, níveis de risco e um dono 
para a Test Suite. Para tal tarefa, você deverá ir para a seção “Test Case 
Suite” e então clicar no menu “Assign Risk and Ownership”. A página “Assign 
Ownership” deverá ser exibida, conforme a Figura 28. 
 
 
Figura 28: Associando riscos ao Test Suite 
Associando usuários ao test suite 
Você poderá associar e realizar o controle de permissões de usuários nos 
Test Suites existentes. Para tal tarefa, você deverá ir para a seção “Test Suite 
Management” e então clicar no menu “Define User / Test Suite Rights”. A 
página “Assign Ownership” deverá ser exibida, conforme a Figura 29. 
 
 
Figura 29: Associando usuários ao Test Suite 
 
 
 
 
 
 
 
44
Criando builds e milestones 
 
À medida que se queira executar os Test Cases de um Test Suite você deverá 
criar um Build. Um Build identifica uma versão ou liberação do software que 
será testado. Toda execução dos Test Cases deve ser associada a um Build. 
Para criar um Build, você deverá ir para a seção “Test Suite Management” e 
então clicar no menu “Build Management”. A página “Create build for Test 
Suite” deverá ser exibida, conforme a Figura 30. 
 
 
Figura 30: Criando um Build 
 
Convém lembrar, aliás, que você poderá criar Milestones a fim de definir 
marcos no tempo do seu projeto. Um Milestone define critérios mínimos que 
devem ser atingidos baseado nos níveis de prioridades associados aos Test 
Suites. Para criar um Milestone, você deverá ir para a seção “Test Suite 
Management” e então clicar no menu “Edit / Delete Milestones”. 
 
 
 
 
 
 
 
 
45
Executando os Test Cases 
 
Uma vez que os Test Suites e os Builds tenham sido criados, você poderá 
executar os Test Cases existentes. Para tal tarefa, você deverá ir para a 
seção “Test Execution” e então clicar no menu “Execute Tests”. A página 
“Test Results” deverá ser exibida, conforme a Figura 31. 
 
 
Figura 31: Executando os Test Cases 
 
Nesta página, o testador poderá selecionar os Test Cases com base nos Test 
Suites existentes ou por meio de filtros criados no menu “Navigation Filter & 
Settings” (área esquerda desta página). 
 
Após a execução do Test Case, o testador deverá definir o resultado da 
execução (Not run, Pass, Failed ou Blocked) e algum comentário caso seja 
necessário. É importante lembrar que as métricas e relatórios são gerados a 
partir dos dados informados pelos testadores durante a execução dos Test 
Cases. 
 
Adicionalmente, o TestLink oferece uma configuração especial que permite a 
integração com Mantis (e outras ferramentas de gestão de defeitos). Essa 
 
46
configuração deverá ser realizada manualmente, conforme descrito no 
manual do TestLink11. Dessa forma, você poderá registrar um bug no Mantis 
e associar este bug ao Test Case que falhou no TestLink, como pode ser visto 
no exemplo apresentado na Figura 32. 
 
 
Figura 32: Associando bugs aos test cases 
 
Por fim, para gerar os relatórios com as métricas de execução dos testes, 
você deverá ir para a seção “Test Execution” e então clicar no menu “Test 
reports and Metrics”. A página “Overview of available Test Reports and 
Metrics” deverá ser exibida. Nesta página você poderá gerar métricas ou 
relatórios de acordo com o Build selecionado. Os diversos relatórios 
existentes agrupam as informações por Build, Test Suite, Componente, 
Keyword, Milestone, Prioridade e até mesmo por Requisito, como pode ser 
observado na Figura 33. 
 
11 http://testlink.org/mantis/file_download.php?file_id=72&type=bug 
 
47Figura 33: Métricas e relatórios gerados pelo TestLink 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
48
Capítulo 3 • Gestão de projetos 
 
A gestão de projetos, assim como a gestão de testes, faz parte do coração de 
um processo de teste (e desenvolvimento) de software. Por meio da gestão 
de projetos, as atividades do projeto são planejadas, organizadas e 
controladas num nível mais macro. A gestão de projetos define e acompanha 
as fases e os principais marcos de um projeto, assim como, os recursos 
humanos e o esforço necessário para atingir os objetivos do projeto. 
 
A gestão de projetos pode ser implementada por meio de ferramentas 
automatizadas (project management system). Essas ferramentas, além de 
viabilizar a gestão de projetos, também oferecem diversas facilidades, como 
por exemplo: repositórios de arquivos, agendas e calendários compartilhados, 
wikis, entre outros. Na figura abaixo, você poderá visualizar a seqüência 
típica de fases no ciclo de vida de um projeto, conforme descrito no 
“Conjunto de Conhecimentos em Gerenciamento de projetos (PMBOK)”: 
 
 
 
Na tabela abaixo você poderá ver a ferramenta que será apresentada nas 
próximas seções: 
 
php-collab 
 
http://www.php-collab.org 
 
 
 
 
 
 
49
php-collab 
 
O php-Collab12 é uma aplicação Open Source cujo principal objetivo é 
gerenciar projetos e facilitar a colaboração entre os membros de um time. O 
php-Collab oferece um recurso onde o projeto pode ser gerenciado sob o 
ponto de vista do time do projeto (gerenciando e exibindo todas as 
informações específicas do projeto) ou do cliente (oferecendo apenas 
informações relevantes ao cliente e dados para o acompanhamento das 
atividades). Entre as diversas funcionalidades oferecidas pelo php-collab, 
devemos destacar as seguintes: 
 
ƒ Pode ser executado em qualquer plataforma que suportar 
PHP/Apache/Mysql (Windows, Linux, Mac, Solaris, AS400/i5, etc); 
ƒ Permite a criação de duas visões do projeto: visão do time e visão do 
cliente; 
ƒ Criação ilimitada de projetos e tarefas; 
ƒ Gerador interno de relatórios e gráficos (possibilidade para exportar os 
dados nos formatos CSV, Excel e Word); 
ƒ Controle de acesso e níveis de permissões por usuário; 
ƒ Organização do projeto por meio de fases, tarefas e sub-tarefas; 
ƒ Integração com o Mantis (ferramenta de gestão de defeitos); 
ƒ Gerenciador integrado de requisições de suporte técnico; 
ƒ Calendários e Bookmarks compartilhados; 
ƒ Gerenciador de listas de discussões; 
ƒ Versionamento de artefatos; 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
12 http://www.php-collab.org (os exemplos deste livro são apresentados com a versão 2.5) 
 
50
Instalando e configurando 
 
Para instalar o php-collab, você deverá seguir os seguintes passos (a título de 
exemplo estamos sugerindo a utilização do XAMMP a fim de satisfazer os 
softwares requeridos para a utilização do php-collab (Apache, MySQL, PHP)). 
 
1. Faça o download do XAMMP13. 
2. Instale e inicialize o XAMMP conforme a orientação do manual ou 
descompacte o arquivo zip em alguma pasta no seu computador. 
3. Após instalado, configure um password para o usuário root do Mysql 
usando um dos métodos sugeridos no site do XAMMP14. 
4. Crie um database no Mysql por meio do phpMyAdmin integrado no 
XAMMP (http://localhost/phpmyadmin/). 
5. Faça o download do php-Collab. 
6. Descompacte o arquivo zip na pasta htdocs do XAMMP (ex: c:\xampp-
win32-1.6.2\xampp\htdocs\phpcollab-2.5). 
7. Abra o seu navegador e acesse o seguinte endereço: 
(http://localhost/phpcollab-2.5/installation/setup.php). 
8. Na janela de instalação, selecione a opção Offline installation 
(firewall/intranet, no update checker). 
9. Na janela Settings, preencha o campo database com o nome do 
database criado no passo 4. Preencha os campos login com 'root' e o 
campo password com a senha configurada no passo 3. Preencha o 
campo Admin Password com o password que você quiser atribuir ao 
administrador. 
10. Deixe os valores default nos demais campos e pressione o botão Save. 
11. Abra o seu navegador e acesse o seguinte endereço: 
(http://localhost/phpcollab-2.5/). 
12. Faça o login com o usuário padrão (admin/a senha definida no passo 
9). 
 
Caso você prefira utilizar esta ferramenta com todos os textos traduzidos 
para a língua portuguesa, então siga os passos descritos abaixo: 
 
1. Abra a janela de login do php-collab. 
2. No campo Language selecione a opção "Brazilian Portuguese". 
3. Faça o login normalmente com o seu usuário e senha. 
 
 
 
 
 
13 http://www.apachefriends.org/en/xampp.html 
14 http://www.apachefriends.org/pt_br/faq-xampp-windows.html 
 
51
 
Criando um novo projeto 
 
Tão logo o php-collab for instalado e configurado, a sua primeira ação deverá 
ser criar um novo projeto. Para tal tarefa, você deverá realizar o login e 
entrar na página principal do php-collab. Esta página exibe todos os projetos, 
tarefas, discussões e notas que estiverem associadas ao seu usuário, como 
pode ser visto na Figura 34. 
 
 
Figura 34: Página principal do php-collab 
 
 
52
Uma vez dentro da página principal, você poderá criar um novo projeto por 
meio do ícone “Add” do menu “Projects”. Durante a criação do projeto, você 
deverá informar o nome do projeto, prioridade, status, entre outras 
informações, como pode ser observado na Figura 35. O campo “Enable 
Phases” habilita a organização do projeto em fases. Dessa forma, cada tarefa 
cadastrada deverá ser associada a uma fase distinta do projeto. O campo 
“Client Organization” habilita a criação e publicação de Websites para o 
cliente, como veremos mais adiante. 
 
 
Figura 35: Criando um novo projeto 
 
Assim que o projeto for criado, você será remetido automaticamente para a 
página de visualização e alteração dos dados do projeto. Nesta página, você 
poderá ver as fases associadas ao projeto, o status de cada fase, a 
quantidade de tarefas existentes, a quantidade de tarefas não concluídas, 
 
53
entre outras informações, como pode ser visto no exemplo apresentado na 
Figura 36. 
 
 
Figura 36: Visualizando e alterando um projeto 
 
 
 
 
 
 
 
 
 
 
 
 
54
Adicionando tarefas 
 
Para adicionar uma tarefa, você deverá entrar na página do projeto e 
selecionar a fase na qual a tarefa será associada. Uma vez dentro da página 
da fase selecionada, você deverá ir para a seção “Tasks” e então clicar no 
ícone “Add”. Durante o cadastramento da tarefa, você deverá informar o 
nome da tarefa, a descrição, a prioridade, o responsável, o tempo estimado, 
entre outras informações, como pode ser visto na Figura 37. 
 
 
Figura 37: Adicionando tarefas ao php-collab 
 
 
 
 
 
55
Visualizando o calendário do projeto 
 
O php-collab oferece um ambiente de gerenciamento integrado, dessa forma, 
todas as tarefas são listadas num calendário comum ao projeto como pode 
ser visto no exemplo apresentado na Figura 38. 
 
 
Figura 38: Calendário compartilhado do projeto 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
56
Listas de discussões 
 
A lista de discussão do php-collab oferece um canal comum e integrado para 
todos os membros do time. Para criar um tópico, você deverá entrar na 
página do projeto. Uma vez dentro desta página, você deverá ir para a seção 
“Discussions” e então clicar no ícone “Add”, conforme o exemplo apresentado 
na Figura 39. 
 
 
Figura 39: Criando uma lista de discussão 
 
Qualquer membro do time pode criar um tópico ou postar uma mensagem. 
Além disso, assim que a discussão for concluída o php-collab permite que o 
tópico seja fechado pelo seu criador, como pode ser observado na Figura 40.57
 
Figura 40: Postando tópicos na lista de discussão 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
58
Adicionando arquivos ao projeto 
 
O php-collab também permite que arquivos sejam adicionados e associados a 
um projeto. Para adicionar um arquivo, você deverá entrar na página do 
projeto. Uma vez dentro desta página, você deverá ir para a seção “Linked 
Content” e então clicar no ícone “Add”, conforme o exemplo apresentado na 
Figura 41. 
 
 
Figura 41: Adicionando arquivos ao projeto 
 
Além de armazenar o arquivo, o php-collab faz o controle do status 
(pendente, aprovado, etc) e o controle de versões do arquivo, como pode ser 
observado na Figura 42. 
 
 
 
59
 
Figura 42: Controle de versões e status dos arquivos 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
60
Bookmarks compartilhados 
 
O php-collab também oferece uma funcionalidade para gerenciar bookmarks 
compartilhados. Para tal tarefa, você deverá clicar no menu “Bookmarks” e 
então clicar no ícone “Add”, conforme o exemplo apresentado na Figura 43. 
 
 
Figura 43: Adicionando bookmarks compartilhados 
 
 
 
 
 
61
Adicionando clientes 
 
Tão logo o projeto seja criado você poderá adicionar clientes e associá-los ao 
projeto. Para tal tarefa, você deverá clicar no menu “Clients” e então clicar no 
ícone “Add”. A página “Add Client Organization” deverá ser exibida conforme 
o exemplo apresentado na Figura 44. Nesta página, você deverá informar o 
nome do cliente, endereço, telefone, entre outras informações. 
 
 
Figura 44: Adicionando clientes 
 
Uma vez que o cliente tenha sido adicionado, você poderá associa-lo a um 
projeto. Na página de visualização das informações do cliente, você também 
poderá criar o site do projeto (sob o ponto de vista do cliente). Para realizar 
tal tarefa, você deverá clicar no link “<details>”, como pode ser observado 
no exemplo exibido na Figura 45. 
 
 
62
 
Figura 45: Visualizando informações dos clientes 
 
Assim que você realizar esta operação, a página “Create Project Site” deverá 
ser exibida, conforme o exemplo apresentado na Figura 46. Nesta página, 
você deverá clicar no botão “Create” para criar definitivamente o site do 
projeto. 
 
Assim que o site do projeto for criado, qualquer usuário cadastrado (Client 
Users) poderá realizar o login e entrar no site do projeto automaticamente. 
Você também poderá acessar o site do projeto por meio do link “Go to 
projects site” localizado no topo direito da página principal do php-collab. 
 
 
Figura 46: Criando o site do projeto 
 
 
63
No site do projeto, o cliente poderá visualizar as tarefas existentes, os 
documentos e as listas de discussões, como pode ser visto na Figura 47. 
 
As informações não são disponibilizadas ao site do projeto automaticamente. 
Para que elas sejam visualizadas no site do projeto, você deverá realizar a 
publicação por meio do ícone “Add to project site” (presente na maior parte 
dos menus do php-collab). 
 
 
Figura 47: Site do projeto 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
64
Requisições de suporte 
 
O cliente, por meio do site do projeto, também poderá realizar requisições de 
suporte. Basicamente, o php-collab fornece um mecanismo simples de gestão 
de requisições de suporte, como pode ser visto no exemplo apresentado na 
Figura 48. 
 
 
Figura 48: Adicionando requisições de suporte 
 
Uma vez que as requisições tenham sido cadastradas pelos clientes, elas 
poderão ser visualizadas e gerenciadas por meio da seção “Support” 
localizada na página do projeto, como pode ser visto na Figura 49. 
 
 
Figura 49: Gerenciando requisições de suporte 
 
 
 
65
Relatórios 
 
O php-collab fornece também um recurso para a geração de relatórios. Por 
meio desse recurso, você poderá filtrar e listar as tarefas com base no 
projeto, cliente, prioridade, data de finalização entre outros filtros, como 
pode ser visto no exemplo apresentado na Figura 50. Adicionalmente, você 
poderá salvar os filtros criados para que o relatório possa ser executado 
posteriormente. 
 
 
Figura 50: Relatórios 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
66
Capítulo 4 • Automação de testes 
funcionais e de aceitação 
 
 
Nos últimos tempos, a automação de testes tem se tornado uma atividade 
vital em projetos de teste de software. A maturidade das ferramentas e a 
vasta quantidade de opções comerciais e Open Source são algumas das 
razões motivadoras para essa mudança de enfoque. Somado a isto, a 
promessa de testes de regressão repetitíveis com baixo custo e o aumento da 
cobertura dos testes, reforçam esse súbito interesse na automação de testes. 
 
Aplicações cada vez mais complexas e orçamentos curtíssimos tornam as 
ferramentas Open Source mais atraentes no mar de opções existentes. Na 
tabela abaixo você poderá ver as ferramentas que serão apresentadas nas 
próximas seções: 
 
selenium 
 
http://www.openqa.org/selenium/ 
marathon 
 
http://www.marathontesting.com/marathon/ 
soapUI 
 
http://www.soapui.org/ 
 
 
 
 
 
 
 
 
 
 
 
 
67
Selenium 
 
O Selenium15 é uma ferramenta Open Source usada para a criação de testes 
de regressão automatizados para aplicações WEB. O Selenium foi escrito 
utilizando Java Script e DHTML. Em função disso, os testes rodam 
diretamente a partir do navegador. Na realidade, em virtude desta 
característica do Selenium, os testes podem rodar virtualmente em qualquer 
navegador que suporte Java Script (Internet Explorer, Firefox, Opera, Safari, 
Konqueror, etc). 
 
Basicamente, os testes do Selenium são escritos em tabelas HTML. Nestas 
tabelas, você informará as operações ou asserções de um teste e os seus 
respectivos argumentos. O Selenium é responsável por interpretar os 
comandos das tabelas HTML e executar as ações, simulando um usuário real. 
 
O Selenium é dividido em dois modos diferentes: 
 
ƒ Selenium Core: Neste modo os testes são executados a partir do WEB 
Server que a aplicação WEB estiver sendo executada. Os testes são 
escritos previamente em tabelas HTML e o TestRunner (Gerenciador 
da execução dos testes) é responsável pela execução dos testes. 
 
ƒ Selenium RC (Remote Control): Neste modo os testes são dirigidos por 
uma das linguagens suportadas pelo Selenium (Ruby16, Python, etc). 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
15 http://www.openqa.org/selenium/ (os exemplos deste livro são apresentados com a 
versão 0.8.2) 
16 http://pt.wikipedia.org/wiki/Ruby_(linguagem_de_programação) 
 
68
Selenium Core 
 
Conforme mencionado anteriormente, neste modo chamado de Selenium 
Core, os testes são executados a partir do WEB Server em que a aplicação 
WEB estiver sendo executada. Para que o Selenium Core funcione 
corretamente, você deverá habilitar o acesso de leitura e escrita nos 
diretórios onde ele for instalado. 
 
 
Figura 51: TestRunner do Selenium Core 
 
Para instalar o Selenium Core, você deverá fazer o download17 a partir do site 
do Selenium. Uma vez feito o download, você deverá descompactar os 
arquivos sob o diretório de deploy do seu WEB Server (Ex: DocumentRoot, 
htdocs, www ou webroot). 
 
Uma vez instalado, você poderá testar se houve sucesso por meio da 
abertura da página TestRunner.html. O TestRunner é a página que gerencia 
a execução dos testes e exibe o relatório de progresso da execução. 
Normalmente esta página está localizada sob o diretório “core”, como pode 
ser observado no exemplo apresentado na Figura 51. 
 
 
 
17 http://www.openqa.org/selenium-core 
 
69
A página do TestRunner é dividida em quatro diferentes áreas: 
 
ƒ TestSuite: Nesta área você deverá escolher a Test Suite que será 
executada pelo Selenium, assim como selecionar um teste da lista de 
testes disponíveis. 
 
ƒ Current Test: Nesta área você poderá visualizar o teste selecionado ou 
o teste que estiver sendo executado. 
 
ƒ Control Panel: Nesta área você poderá gerenciar a execução dos testes 
(rodar apenas os testes selecionados, diminuir a velocidade de 
execução dos testes, executar os testes passo a passo, ver o log de 
execução e o resultado da execução dos testes). 
 
ƒ AUT: Nesta área localizada na parte inferior da página, você visualizará 
a aplicação em teste durante a execução dos testes. Você também 
poderá configurar o Selenium para exibir a aplicação em teste em uma 
janela separada por meio da opção “AUT in separate window” ou pelo 
parâmetro "multiWindow=true" da página “TestRunner.html”. No 
entanto, o Firefox não suporta nativamente o multi-window mode. 
Para resolver este problema, você deverá baixar o add-on 
readyState.xpi18. 
 
É importante lembrar que você deverá desabilitar os bloqueadores de pop-up, 
gerenciadores de senhas e recursos semelhantes do navegador antes da 
execução dos testes automatizados, para garantir que os testes não falhem 
ou travem em virtude de algum desses recursos oferecidos pela maioria dos 
navegadores. 
 
Naturalmente, para executar os testes por meio do Selenium Core, você 
deverá ter criado previamente os casos de testes para a sua aplicação WEB. 
Conforme mencionamos anteriormente, os testes são escritos em tabelas 
HTML. Nestas tabelas, você informará as operações ou asserções de um teste 
e os seus respectivos argumentos. 
 
A sintaxe destes comandos é chamada de “Selenese”, ou em bom português: 
“Selenês”. Um teste escrito em Selenês é basicamente composto por uma 
tabela contendo três colunas. Uma coluna é usada para a operação e as duas 
restantes são usadas para os argumentos. Cabe lembrar que nem todas as 
operações requerem dois argumentos, como pode ser visto no exemplo 
apresentado na Figura 52. 
 
 
18 http://www.openqa.org/selenium-core/download/readyState.xpi 
 
70
 
Figura 52: Caso de teste escrito em Selenês 
 
Cabe ressaltar que as linhas com menos de três colunas serão 
automaticamente ignoradas pelo Selenium. Neste caso, você poderá utilizá-
las para comentários ou para o título do caso de teste. Por questões 
estéticas, você poderá usar a tag HTML “&nbsp” para fazer as células da 
tabela ficarem esteticamente melhores, ao invés de apenas exibir um espaço 
vazio. 
 
De forma similar, os Test Suítes também são representados em tabelas 
HTML. Cada Test Suite referencia um ou mais casos de teste. No entanto, o 
código HTML usado para o Test Suite, tem uma pequena particularidade: a 
tag HTML “target” deve sempre referenciar o frame “testFrame” para que os 
casos de teste sejam adequadamente exibidos na área Test Suíte do 
TestRunner, conforme discutido anteriormente. Observe o exemplo 
apresentado na Figura 53: 
 
 
Figura 53: Código HTML da Test Suite 
 
71
De um ponto de vista genérico, as operações suportadas pelo Selenês são 
divididas em três grupos distintos: 
 
ƒ Actions: Representam as operações realizadas pelo usuário durante a 
utilização da aplicação WEB. A maioria das Actions representam ações 
do tipo (clicar em determinado link ou botão, selecionar determinada 
opção e assim por diante). Se a execução de uma Action falhar, o 
status do teste é modificado para “Failed” e o teste é imediatamente 
paralisado. Adicionalmente, você poderá adicionar o sufixo “AndWait” 
para a maioria das Actions. Este sufixo informa ao Selenium que a 
ação gerou uma requisição ao servidor e a execução do teste precisa 
esperar que a página seja recarregada. 
 
ƒ Accessors: Executa uma asserção (compara o estado ou propriedade 
de um objeto da página contra um valor esperado) e armazena o 
resultado numa variável. O resultado negativo de uma Accessor não 
paralisa a execução do teste, mas no entanto, a falha é exibida no 
resultado dos testes. 
 
ƒ Assertions: Executa uma asserção (compara o estado ou propriedade 
de um objeto da página contra um valor esperado). No entanto, a 
Assertion não armazena o resultado numa variável. O resultado 
negativo de uma Assertion não paralisa a execução do teste, mas no 
entanto, a falha é exibida no resultado dos testes. 
 
Infelizmente, não faz parte do escopo deste livro apresentar minuciosamente 
as operações suportadas pelo “Selenês”. Com certeza, um livro inteiro 
poderia ser escrito para descrever e mostrar exemplos práticos de todas as 
operações existentes. Neste caso, o autor sugere que você leia o “Reference 
Guide”19 do Selenês no site do Selenium. 
 
Por outro lado, você não precisa decorar todas as operações suportadas pelo 
Selenês. Por meio de um ambiente gráfico integrado chamado Selenium IDE, 
você poderá gravar e reproduzir os testes sem escrever uma única operação 
em Selenês, como veremos mais adiante. 
 
 
 
 
 
 
 
 
19 http://release.openqa.org/selenium-core/nightly/reference.html 
 
72
Selenium IDE 
 
O Selenium IDE20 é um ambiente gráfico integrado ao Firefox capaz de 
gravar e reproduzir os testes do Selenium. O Selenium IDE captura e grava 
as suas ações no Firefox. Essas ações são convertidas para o Selenês 
automaticamente para que você possa salvar o teste, executá-lo e depurá-lo 
individualmente ou em conjunto com outros testes numa Test Suite. 
 
O Selenium IDE é uma extensão do Firefox, como pode ser visto na Figura 
54. Uma vez instalado, você poderá executar o Selenium IDE acessando o 
menu “Tools>Selenium IDE”, de acordo com o exemplo apresentado na 
Figura 55. 
 
 
Figura 54: Instalando o Selenium IDE 
 
Uma vez aberta a janela do Selenium IDE, qualquer ação que você executar 
nas páginas do navegador será convertida para uma operação em Selenês na 
aba “Table”. No entanto, o Selenium IDE não se limita apenas a reproduzir os 
cliques ou preenchimento dos campos realizados durante a navegação. Você 
também poderá selecionar qualquer uma das operações suportadas pelo 
Selenês conforme a sua necessidade por meio do campo “Command”. Vale a 
pena destacar que, conforme o comando selecionado, uma descrição 
completa da sua utilização e argumentos requeridos é apresentada na parte 
inferior da janela do Selenium IDE. 
 
 
20 http://www.openqa.org/selenium-ide/ (os exemplos deste livro são apresentados com a 
versão 0.8.6) 
 
73
 
Figura 55: Selenium IDE 
 
Adicionalmente, o Selenium IDE adiciona novos menus de contexto no 
Firefox. Neste caso, durante gravação da navegação, você poderá selecionar 
qualquer objeto da página e adicionar uma operação ou asserção de acordo 
com o contexto do objeto selecionado, como pode ser visto no exemplo 
apresentado na Figura 56. 
 
74
 
Figura 56: Operações integradas aos menus do Firefox 
 
Por fim, assim que você finalizar gravação da navegação da sua aplicação 
WEB, todos os passos executados serão convertidos automaticamente em 
Selenês e estarão disponíveis na aba “Table”. O teste poderá ser salvo no 
formato HTML para que seja posteriormente executado. 
 
Você também poderá executar, pausar ou depurar o teste por meio do 
Selenium IDE. Adicionalmente, o Selenium IDE empacota internamente por 
default o Selenium Core. Neste caso, você também poderá executar o teste 
por meio do TestRunner do Selenium Core, como pode ser visto na Figura 57. 
 
 
 
 
75
 
Figura 57: Executando os Testes no Selenium Core 
 
Todo navegador, por default, oferece mecanismos de segurança para evitar 
ataques do tipo XSS “cross-site scripting”. Toda extensão do Firefox tem 
acesso ao protocolo Chrome (específicodeste navegador). Esse protocolo 
oferece um meio alternativo para burlar a segurança dos navegadores para 
evitar os ataques do tipo XSS. 
 
No exemplo da Figura 57, o Selenium Core não precisou ser instalado no 
WEB Server em que a aplicação WEB estava sendo executada em virtude 
dessa característica do Firefox. 
 
Dessa forma, você poderá executar as suas Teste Suítes a partir do Firefox 
sem a necessidade de instalar o Selenium Core no mesmo WEB Server onde 
a aplicação WEB estiver sendo executada. Para realizar tal tarefa, você 
deverá utilizar a seguinte URL para executar o TestRunner a partir do Firefox: 
 
 
 
 
76
 
 
Onde: 
ƒ baseURL: Indica a URL base da aplicação WEB. 
ƒ test: Indica a localização da Test Suite. 
ƒ auto: Indica que o TestRunner deverá executar os testes assim que for 
aberto. 
 
Por último, devemos destacar que você também poderá testar aplicações 
WEB baseadas em AJAX (Asynchronous JavaScript and XML) utilizando o 
Selenium IDE. Sem discutir em detalhes, uma página AJAX é capaz de 
realizar diversas operações sem, no entanto, precisar buscar ou trocar muitas 
informações com o WEB Server. 
 
Neste caso, normalmente a página não é recarregada, garantindo assim 
maior velocidade nas operações. No entanto, neste cenário, operações em 
Selenês do tipo “clickAndWait” não funcionarão corretamente em virtude de 
que a página AJAX não será recarregada. 
 
Para solucionar esta limitação e viabilizar os testes de páginas AJAX, você 
deverá utilizar, por exemplo, a operação “waitForValue” que aguardará a 
mudança do valor definido como argumento, ao invés de esperar a página 
recarregar. 
 
Existem muitas páginas21 na Internet apresentando soluções e exemplos para 
testes de páginas AJAX utilizando o Selenium. Vale a pena conferir também 
os exemplos apresentados no site do Selenium. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
21 http://www.infoq.com/articles/testing-ajax-selenium 
 
77
Selenium RC (Remote Control) 
 
No modo chamado de Selenium RC22 (Remote Control), os testes são 
executados por meio de uma das linguagens de programação suportadas 
pelo Selenium. O Selenium RC é a melhor solução quando os testes escritos 
em Selenês nas tabelas HTML não forem suficientes para as suas 
necessidades. 
 
Se você precisar de uma lógica mais complexa de controle, fluxos, acesso a 
banco de dados ou leitura de informações externas, sem dúvida, o Selenium 
RC será de grande ajuda. 
 
 
Figura 58: Arquitetura do Selenium RC 
 
A arquitetura do Selenium RC é extremante simples e eficaz (Figura 58). 
Basicamente, o Selenium RC expõe uma interface (Wrapper API) para os 
comandos em Selenês. Já existem interfaces escritas para as principais 
linguagens de programação da atualidade23 (Java, .NET, Perl, Python, and 
Ruby). 
 
Durante a execução do teste na linguagem escolhida por você, os comandos 
executados por meio dessas interfaces se comunicam com o Selenium Server, 
que é a outra parte da arquitetura do Selenium RC. O Selenium Server, de 
acordo com o site do Selenium, é onde a mágica acontece. 
 
Por meio do Selenium Server, uma instância do navegador escolhido por você 
é iniciada nos bastidores. Assim, toda a vez que o teste executa uma 
 
22 http://www.openqa.org/selenium-rc/ 
23 http://www.openqa.org/selenium-rc/tutorial.html 
 
78
operação, na verdade ele se comunica com o Selenium Server, que por sua 
vez se comunica com essa instância do navegador (usando XmlHttpRequest 
do AJAX). 
 
 
Figura 59: Selenium Server no modo interativo 
 
Além desse modo de execução convencional, o Selenium Server oferece 
também um modo interativo. Neste modo, você poderá interagir diretamente 
com Selenium Server por meio da digitação de comandos (Selenês) no seu 
prompt. 
 
Para inicializar o Selenium Server em modo interativo, execute o seguinte 
comando “java -jar selenium-server.jar -interactive”, como pode ser visto no 
exemplo apresentado na Figura 59 (o output dos comandos foram 
propositalmente omitidos). 
 
Adicionalmente, você poderá utilizar o Selenium IDE para criar os testes 
usados pelo Selenium RC. O Selenium IDE tem um recurso que permite a 
exportação dos testes em Selenês para a maioria das linguagens suportadas 
pelo Selenium RC, como pode ser observado na Figura 60. 
 
 
79
 
Figura 60: Exportando os testes para outras linguagens 
 
Como resultado do processo de exportação, obtemos o código fonte na 
linguagem alvo escolhida por você. No exemplo apresentado na Figura 61, 
você poderá ver o resultado da exportação para a linguagem Ruby. 
 
 
80
 
Figura 61: Trecho de um teste exportada para Ruby 
 
Para confirmar se o teste foi exportado com sucesso, execute o Selenium 
Server por meio do comando “java –jar selenium-server.jar”. Em outra janela 
do prompt execute o seu teste, como pode ser visto no exemplo apresentado 
na Figura 62. 
 
 
81
 
Figura 62: Executando um teste usando o Selenium RC 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
82
Marathon 
 
O Marathon24 é uma ferramenta Open Source de testes de regressão 
automatizados para aplicações Java desenvolvidas com o toolkit gráfico 
Swing25. Utilizando o Marathon, você poderá criar testes automatizados por 
meio da captura das suas ações (cliques do mouse, digitação, etc). Estas 
ações são convertidas em scripts Jython26 (implementação Java da linguagem 
de script Python) para que você possa executar posteriormente o teste. 
Dentre as suas principais características, podemos destacar as seguintes: 
 
ƒ Ambiente de desenvolvimento integrado onde você poderá capturar, 
depurar e executar os testes automatizados; 
 
ƒ Módulos reutilizáveis para facilitar a manutenção; 
 
ƒ Fixtures (scripts em Jython cuja principal função é criar as pré-
condições de execução dos testes, assim como, a posterior limpeza 
dos recursos criados); 
 
ƒ Component Resolver e Custom Component Resolver (recurso utilizado 
para detectar todos os componentes do Swing (botões, campos de 
edição, menus, etc), assim como os seus métodos e propriedades); 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
24 http://www.marathontesting.com/ (os exemplos deste livro são apresentados com a 
versão 1.0.3) 
25 http://en.wikipedia.org/wiki/Swing_(Java) 
26 http://www.jython.org/Project/index.html 
 
83
Criando um novo projeto 
 
Assim que o Marathon for instalado, a sua primeira ação será criar um novo 
projeto. Para realizar tal tarefa, você deverá escolher a opção “New” da 
janela “Create and manage configuration”. 
 
Uma janela solicitando o nome do projeto deverá ser exibida, como pode ser 
visto na Figura 63. É importante lembrar que durante a criação do projeto, 
você deverá obrigatoriamente informar corretamente a “Main Class” da 
aplicação Java que será testada, assim como o seu “Class Path”27. Caso 
contrário, o Marathon não será capaz de inicializar a aplicação Java. 
 
 
Figura 63: Criação de um novo projeto 
 
 
27 http://pt.wikipedia.org/wiki/Java_(linguagem_de_programação) 
 
84
Tão logo o projeto seja criado, a janela principal do Marathon é exibida. Esta 
janela oferece um ambiente de desenvolvimento integrado onde você poderá 
capturar, depurar e executar os testes automatizados, como pode ser 
observado na Figura 64. 
 
 
Figura 64: Janela principal do Marathon 
 
Os projetos do Marathon são compostos por três elementos distintos (todos 
esses elementos serão discutidos mais adiante): 
 
ƒ TestCases: Scripts em Jython que representam as ações (cliques do 
mouse e digitação) e asserções realizadas por vocêdurante a captura 
(gravação); 
 
ƒ Modules: Scripts em Jython usados por outros testes (módulos 
reutilizáveis). Por meio dos Modules, você poderá aumentar a 
reutilização e facilitar a manutenção no futuro. 
 
ƒ Fixtures: Scripts em Jython cuja função é criar as pré-condições de 
execução dos testes, assim como, a posterior limpeza dos recursos 
criados. 
 
 
85
Por fim, para efeitos didáticos, os exemplos apresentados nas próximas 
seções serão realizados utilizando um editor simples de UML desenvolvido em 
Java chamado Violet28, como pode ser visto no exemplo apresentado na 
Figura 65. 
 
 
Figura 65: Violet UML Editor 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
28 http://www.horstmann.com/violet/ 
 
86
Criando um script de teste 
 
Para criar um novo script de teste, você deverá clicar no menu 
“File>New>Test Case”. A janela “Untitled” deverá ser exibida no editor. Esta 
janela representa um script de teste em branco. 
 
A partir deste ponto, poderemos começar a capturar (ou gravar) o script de 
teste automatizado, por meio do botão “Record” localizado na barra de 
ferramentas do Marathon. 
 
Tão logo você comece a captura, o Marathon abrirá automaticamente a 
aplicação em teste (no nosso caso, o Violet) e, em background, a janela 
“Marathon Control Center”, como pode ser visto na Figura 66. 
 
 
Figura 66: Marathon Control Center 
 
Por meio da janela “Marathon Control Center” todas as ações são capturadas 
e traduzidas para comandos Jython. Adicionalmente, esta janela fornece 
opções para pausar, retornar da pausa, parar a captura e a adição de 
módulos reutilizáveis (os módulos reutilizáveis serão discutidos mais adiante). 
 
É importante ressaltar que o Marathon utiliza um recurso chamado 
“Component Resolver” para detectar todos os componentes do Swing 
(botões, campos de edição, menus, etc), assim como os seus métodos e 
propriedades. É por meio desse recurso que o Marathon é capaz de mapear 
os componentes da aplicação e converter as suas ações em comandos 
Jython. 
 
No entanto, caso a sua aplicação tenha algum componente personalizado, 
que não faz parte da biblioteca padrão do Swing, você poderá criar um 
 
87
“Custom Component Resolver” para que o Marathon possa detectar o seu 
componente. 
 
Ao final da gravação, o Marathon fecha automaticamente a aplicação em 
teste e adiciona ao script de teste todas ações capturadas (traduzidas para 
comandos Jython). No nosso exemplo, foi criado um script de teste para 
testar a criação de um diagrama de caso de uso, como pode ser observado 
na Figura 67. 
 
 
Figura 67: Script de teste captura pelo Marathon 
 
Entretanto, como você poderá notar, este script de teste não realiza 
nenhuma verificação (nenhuma informação é comparada com algum 
resultado esperado). Para adicionar esse tipo de verificação durante a 
captura, você deverá usar um recurso chamado “Assertions” (ou 
verificações). 
 
Por meio das “Assertions”, você poderá comparar qualquer informação 
contida em qualquer componente da aplicação (botões, campos de edição, 
menus, etc) contra um resultado esperado. Para adicionar uma asserção 
durante a captura do script de teste, você deverá usar o atalho (CTRL+F8) 
ou (CTRL+Botão direito do mouse) sobre o componente desejado. 
 
Um menu pop-up será exibido com a lista de asserções disponíveis. No 
exemplo apresentado na Figura 68, você poderá notar o novo script criado 
com as “Assertions”. 
 
88
 
Figura 68: Adicionando asserções aos scripts de teste 
 
 
 
 
 
 
 
 
89
Criando um módulo reutilizável 
 
Os módulos reutilizáveis são uma alternativa para evitar que passos 
repetitíveis sejam replicados em diversos scripts de teste. Dessa forma, 
aumentamos a reutilização de código e, por sua vez, diminuímos o tempo de 
manutenção dos scripts. 
 
Para criar um módulo reutilizável você deverá clicar no menu 
“File>New>Capture Script”. A janela “Untitled” deverá ser exibida no editor. 
Assim como no script de teste, você deverá realizar a captura das ações por 
meio do botão “Record” localizado na barra de ferramentas do Marathon. 
 
Ao final da gravação, o Marathon fechará automaticamente a aplicação em 
teste e todas as ações capturadas serão adicionadas ao módulo reutilizável 
(traduzidas para comandos Jython), como pode ser visto na Figura 69. 
 
 
Figura 69: Criando um módulo reutilizável 
 
No nosso exemplo, foi criado um módulo reutilizável com os passos para 
acessar o menu do Violet e criar um novo diagrama de caso de uso. Para 
adicionar o módulo reutilizável a um script de teste, você deverá clicar no 
botão “Insert Script” da janela “Marathon Control Center” durante a captura 
(gravação). 
 
 
90
A janela “Insert Script” deverá ser exibida. Você deverá escolher um dos 
scripts disponíveis para a reutilização e, se for o caso, informar o parâmetro 
do módulo reutilizável, como pode ser visto na Figura 70. 
 
 
Figura 70: Adicionando um módulo reutilizável ao script de teste 
 
Uma vez que esses passos forem realizados com sucesso, o Marathon 
adicionará uma chamada ao módulo reutilizável dentro do script de teste, 
como pode ser observado no exemplo apresentado na Figura 71. 
 
 
Figura 71: Executando um módulo reutilizável dentro de teste 
 
 
 
 
 
 
 
 
 
 
 
 
91
Executando os scripts de teste por meio do JUnit 
 
Você poderá executar qualquer script de teste por meio do botão “Play” ou 
“Slow Play” localizados na barra de ferramentas do Marathon. No entanto, o 
Marathon oferece um “Test Runner” baseado no JUnit29 para a execução e 
geração de um relatório de status das suítes de testes. 
 
Para realizar tal tarefa, você deverá selecionar a aba “JUnit” e clicar no botão 
“Run All Tests” ou “Run Selected Tests”. Ao final da execução, será exibido o 
resumo do status da execução dos scripts de testes. 
 
No entanto, você poderá clicar no botão “Test Report” para visualizar o 
relatório HTML com todos os detalhes da execução dos testes, como pode ser 
observado no exemplo apresentado na Figura 72. 
 
 
 
Figura 72: Executando os scripts de teste por meio do JUnit 
 
 
 
 
 
 
 
29 http://en.wikipedia.org/wiki/JUnit 
 
92
Criando uma fixture 
 
Conforme discutido anteriormente, uma “Fixture” representa um script 
personalizado cuja função é criar as pré-condições de execução dos testes, 
assim como, a posterior limpeza dos recursos criados. 
 
Dessa forma, caso o script de teste precise que seja criado um diretório e 
uma chave de registro no Windows com determinado valor, você poderá 
resolver esse problema por meio da operação de Inicialização (Setup) de uma 
“Fixture”. 
 
Por outro lado, para garantir que o ambiente esteja limpo para a execução do 
próximo script de teste, você poderá excluir o diretório e a chave de registro 
por meio da operação de Finalização (Teardown). 
 
Para criar uma nova “Fixture”, você deverá clicar no menu 
“File>New>Fixture”. A janela “Untitled” deverá ser exibida no editor. Esta 
janela representa uma nova “Fixture” com as operações default de 
Inicialização (Setup) e Finalização (Teardown). 
 
 
Figura 73: Criando uma fixture 
 
A partir desse ponto, você deverá codificar a “Fixture” conforme a sua 
necessidade. No nosso exemplo, vamos criar uma nova “Fixture” chamada 
“clean_up_fixture” que executará a criação de um diretório chamado 
“tempdir” na Inicialização (Setup), como pode ser visto na Figura 73. 
 
Como você deve ter notado, foram utilizados comandos do Jython para 
customizar a “Fixture”. O Marathon oferece a biblioteca de comandos básica 
 
93
do Jython, mas no entanto, caso seja necessário utilizar recursos avançados, 
você deverá instalar ointerpretador do Python30 no seu computador. 
 
Uma vez instalado, você deverá informar ao Marathon o “Path” do Python por 
meio da janela “Create and manage configuration”. Para realizar tal tarefa, 
você deverá clicar no menu “Marathon>Project Settings”, como pode ser 
observado no exemplo apresentado na Figura 74. 
 
 
Figura 74: Configurando o path do Python 
 
Uma vez que a “Fixture” for criada, você poderá associa-la a um script de 
teste. Para tal tarefa, você deverá clicar no menu “Marathon>Select Fixture”, 
como pode ser observado no exemplo apresentado na Figura 75. 
 
 
Figura 75: Selecionando uma fixture default 
 
30 http://www.python.org/download/ 
 
94
SoapUI 
 
SoapUI31 é uma ferramenta Open Source escrita em Java cuja principal 
função é consumir e testar WEB Services32. WEB Service é uma tecnologia 
baseada em XML e HTTP cuja principal função é disponibilizar serviços 
interativos na WEB que podem ser acessados (ou consumidos) por qualquer 
outra aplicação independente da linguagem ou plataforma em que a 
aplicação foi construída. 
 
O SOAP (Simple Object Access Protocol) é o padrão universal utilizado para a 
troca de mensagens entre as aplicações consumidoras e o WEB Service. O 
WEB Service expõe as suas operações por meio de um tipo de esquema XML 
chamado WSDL (WEB Service Description Language). 
 
Neste contexto, o SoapUI facilita todo o processo de criação e depuração dos 
testes por meio de uma interface gráfica intuitiva. Dentre as suas principais 
características, podemos destacar as seguintes: 
 
ƒ Importação e geração automática das requisições descritas no WSDL; 
ƒ Capacidade de gerenciar um número ilimitado de requisições para 
cada operação; 
ƒ Gerenciamento de múltiplos endpoints para cada WEB Service; 
ƒ Validação das requisições e respostas contra as suas definições no 
WSDL; 
ƒ Testes funcionais, desempenho e stress; 
ƒ Execução de diversos testes em paralelo; 
ƒ Editores com syntax highlight e formatação automática; 
ƒ Suporta expressões XPATH; 
ƒ Suporta criação de testes complexos utilizando scripts Groovy33; 
 
 
 
 
 
 
 
 
 
 
 
 
31 http://www.soapui.org/ (os exemplos deste livro são apresentados com a versão 1.5) 
32 http://en.wikipedia.org/wiki/WEB_service 
33 http://groovy.codehaus.org/ 
 
95
Criando um novo projeto 
 
Para iniciar a utilização do SoapUI, você deverá criar um novo projeto. Para 
tal tarefa, você deverá clicar no menu “File>New WSDL Project”, como pode 
ser visto na Figura 76. O SoapUI abrirá um diálogo solicitando o nome do 
novo projeto. Você também precisará informar em qual pasta o projeto será 
salvo. 
 
 
Figura 76: Criação de um novo projeto do SoapUI 
 
Para efeitos didáticos e de entendimento, os exemplos apresentados nas 
próximas seções vão realizar os testes de um suposto WEB Service chamado 
“EchoService”. Este WEB Service expõe uma operação chamada “HelloEcho” 
cujo único propósito será ecoar o texto enviado, ou seja, se você enviar “Olá 
Mundo!” a resposta será “Olá Mundo!”. 
 
Dando continuidade, assim que o projeto for criado, ele aparecerá listado na 
árvore de projetos localizada na área esquerda da janela principal do SoapUI. 
Em seguida, devemos importar o WSDL a fim de que o SoapUI seja capaz de 
conhecer todas as operações expostas pelo “EchoService”. 
 
Para realizar esta tarefa, você deverá clicar com o botão direito do mouse 
sobre o nome do projeto e escolher a opção “Add WSDL from file”, como 
 
96
pode ser visto na Figura 77. Lembre-se de confirmar a criação das 
Requisições Default para todas as operações quando for solicitado. 
 
 
Figura 77: Importação das interfaces via um arquivo WSDL 
 
Ao final do processo de importação do WSDL, o SoapUI incluirá um novo item 
abaixo do nome do projeto representando o WSDL importado. Clicando-se 
duas vezes sobre este novo item, você abrirá a janela “Interface Viewer”. Por 
meio dessa janela você poderá ver o conteúdo do WSDL recém importado. 
 
Adicionalmente, o SoapUI criará uma Requisição Default (Request 1) para 
cada operação exposta pelo WEB Service “EchoService”, como pode ser visto 
na Figura 78. 
 
 
97
 
Figura 78: Interface Viewer 
 
As Requisições Default são criadas para facilitar a criação dos Test Cases. 
Você também poderá testar o acesso ao WEB Service clicando com o botão 
direito do mouse sobre a Requisição Default da operação que você desejar e, 
em seguida, escolher a opção “Open Request Editor”. No nosso cenário, você 
deverá abrir a Requisição Default da operação “HelloEcho”. 
 
A janela “Request Editor” deverá ser exibida. No lado esquerdo desta janela 
aparecerá a requisição SOAP que será enviada ao “EchoService”. Você deverá 
preencher os parâmetros desta requisição conforme os tipos definidos no 
WSDL. 
 
Para consumir a operação “HelloEcho” exposta pelo WEB Service 
“EchoService”, devemos apenas fornecer uma string no único parâmetro 
disponível e, então, submeter a requisição. A resposta desta requisição é 
imediatamente exibida no lado direito do “Request Editor”, como pode ser 
visto na Figura 79. 
 
 
98
 
Figura 79: Submetendo uma requisição ao WEB Service 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
99
Criando um test case 
 
Para criar um novo Test Case, clique com o botão direito do mouse sobre a 
Requisição Default da operação que você desejar e escolha a opção “Add to 
TestCase”. No nosso caso, devemos selecionar a Requisição Default “Request 
1”. 
 
Durante a criação do Test Case, você também deverá informar o nome da 
Test Suite, o nome do Test Case e o nome do Test Step (no nosso exemplo, 
chamaremos de “Testes Básicos”, “Test 1” e “Envia string Hello World”, 
respectivamente). Em resumo, uma Test Suite serve para agrupar um 
conjunto de Test Cases com características semelhantes. Cada Test Case é 
formado por um ou mais Test Steps (passos). Por sua vez, cada Test Step 
representa uma requisição que será enviada ao WEB Service. 
 
 
Figura 80: Criando um Test Case 
 
Após a conclusão da criação do Test Case, o SoapUI incluirá um novo item 
abaixo do nome do projeto representando a Test Suite e o Test Case, 
respectivamente. Clicando-se duas vezes sobre o ícone da Test Suite, você 
abrirá a janela "Test Suite Runner". Por meio desta janela você poderá iniciar 
a execução de todos os Test Cases existentes na Test Suite, como pode ser 
visto na Figura 80. 
 
100
Para editar ou depurar os Test Steps, dê um duplo clique sobre o nome do 
Test Step. O SoapUI abrirá a janela “Test Step Editor”. Por meio desta janela, 
você poderá editar e inspecionar a resposta da requisição, como pode ser 
visto na Figura 81. 
 
 
Figura 81: Edição dos Test Steps 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
101
Criando asserções 
 
Por meio da janela “Test Step Editor”, você também poderá definir asserções 
(ou verificações) que serão executadas contra a resposta da requisição. Você 
poderá adicionar uma asserção clicando com o botão direito do mouse na 
aba “Assertions” localizada na parte inferior da janela “Test Step Editor” 
(Figura 82). 
 
 
Figura 82: Adicionando asserções 
 
Atualmente, o SoapUI oferece cinco tipos diferentes de asserções (ou 
verificações) para validar a resposta de uma requisição, como pode ser visto 
na Tabela 1. 
 
 
Asserção Descrição 
Schema 
Compliance 
Valida as respostas das requisições contra o xml-
schema definido no WSDL 
Simple Contains Verifica a existência de uma string nas respostas das 
requisições 
 
102
Simple 
NotContains 
Verifica a não existência de uma string nas respostas 
das requisições 
SOAP Fault Verifica se a resposta da requisição contémum soap-
fault 
XPath Match Compara o conteúdo das respostas das requisições 
contra uma expressão XPATH34 
Tabela 1: Asserções fornecidas pelo SoapUI 
 
Basicamente, as asserções servem para confirmar se a resposta de uma 
requisição contém as informações esperadas. Se as asserções falharem, o 
Test Step e o Test Case indicarão um status de falha, como pode ser visto na 
Figura 83. 
 
 
 
Figura 83: Asserções 
 
34 http://en.wikipedia.org/wiki/XPath 
 
103
Depurando os Test Cases 
 
Para analisar os logs de execução dos Test Steps dê um duplo clique no Test 
Step desejado. A janela “Test Step result” deverá ser exibida como pode ser 
observado na Figura 84. Nesta janela você poderá visualizar as propriedades 
da requisição, os dados enviados, os dados recebidos, entre outras 
informações. 
 
 
Figura 84: Depurando Test Cases complexos por meio do Test Result Log 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
104
Adicionando novos Test Steps ao Test Case 
 
Conforme mencionamos anteriormente, cada Test Step é criado a partir de 
uma operação exposta pelo WEB Service. No entanto, o SoapUI fornece 
outros tipos de Test Steps para nos ajudar a criar testes mais complexos. 
 
Para adicionar um novo Test Step, clique com o botão direito do mouse na 
seção “Test Steps” localizada na parte superior da janela “Test Step Editor” e 
selecione a opção “Insert Step”, como pode ser visto na Figura 85. 
 
 
Figura 85: Adicionando novos Test Steps no Test Case 
 
Atualmente, o SoapUI oferece cinco tipos diferentes de Test Steps que 
podem ser adicionados ao Test Case, conforme descrito na Tabela 2. 
 
 
 
 
105
 
 
Test Step Descrição 
Groovy Script Permite a utilização do Groovy (linguagem de script 
baseada em Java) para criar Test Steps e Asserções 
complexas 
Conditional Goto Fornece a possibilidade de mudar o fluxo de execução 
dos Test Steps de acordo com alguma condição especial 
Properties Armazena propriedades para serem utilizadas entre os 
Test Steps como se fossem variáveis 
Delay Simula uma espera/atraso de acordo com o tempo 
determinado por você 
Property 
Transfer 
Transfere dados entre os Test Steps 
Tabela 2: Test Steps suportados pelo SoapUI 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
106
Criando testes de desempenho e stress 
 
Entre outras características, o SoapUI também oferece um recurso para 
executar testes de desempenho e stress contra os WEB Services. 
Basicamente, a idéia é executar os Test Cases contra um WEB Service 
simulando milhares de usuários concorrentes durante um período de tempo. 
 
 
Figura 86: Testes de desempenho e stress 
 
Você também poderá criar asserções para identificar se o WEB Service está 
atendendo determinado requisito de performance de acordo com as suas 
necessidades, como pode ser observado na Figura 86. 
 
Caso o WEB Service demore mais tempo do que o tempo definido na 
asserção, é inserido um registro no log. O SoapUI também exibe gráficos 
com as estatísticas da execução dos testes para facilitar a leitura e a análise 
dos dados, conforme apresentado na Figura 87. 
 
 
107
 
Figura 87: Gráfico com as estatísticas dos testes de desempenho 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
108
Capítulo 5 • Automação de testes de 
performance 
 
A automação de testes de performance, assim como a automação de testes 
funcionais e de aceitação, também vem encontrando destaque nos projetos 
de teste de software. Os holofotes têm brilhado sobre a automação de testes 
de performance em virtude de um fenômeno contemporâneo da indústria de 
TI: a mudança de plataforma das aplicações legadas para a plataforma WEB. 
A migração para a plataforma WEB trouxe novos desafios sob o ponto de 
vista do planejamento e execução dos testes, tais como: performance, 
segurança, suportabilidade, usabilidade e assim por diante. 
 
Novamente, orçamentos freqüentemente curtíssimos tornam as ferramentas 
Open Source mais atraentes no mar de opções existentes. Na tabela abaixo 
você poderá ver as ferramentas que serão apresentadas nas próximas 
seções: 
 
JMeter 
 
http://jakarta.apache.org/jmeter/index.html 
Microsoft 
WEB 
Application 
Stress 
Tool 
 
http://www.microsoft.com/downloads/details.aspx?FamilyID=e2
c0585a-062a-439e-a67d-75a89aa36495&DisplayLang=en 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
109
JMeter 
 
O JMeter35 é uma ferramenta Open Source de testes de performance 
automatizados para aplicações WEB. O JMeter oferece recursos para realizar 
testes de performance, volume e estresse automatizados para aplicações 
WEB, servidores FTP, WEB Services, Banco de Dados, entre outros. 
 
Por ser uma ferramenta inteiramente escrita em Java, o JMeter poderá ser 
executado em qualquer plataforma que suporte a máquina virtual do Java. 
Além disso, o JMeter facilita todo o processo de criação e depuração dos 
testes por meio de uma interface gráfica intuitiva. 
 
Os testes podem ser escritos manualmente (por meio da criação manual das 
requisições HTTP36) ou gravados automaticamente enquanto você navega na 
aplicação simulando um usuário real (por meio de um Proxy Server). 
 
Entre os diversos recursos oferecidos pelo JMeter, devemos destacar: 
 
ƒ Pode ser executado em qualquer plataforma que suporte a máquina 
virtual do Java 1.4 ou superior (Solaris, Linux, Windows, OpenVMS 
Alpha 7.3+); 
ƒ Suporta a criação de testes de performance para os protocolos (HTTP, 
JDBC, FTP, JMS, LDAP, SOAP, entre outros); 
ƒ Possibilidade de executar os testes em computadores distribuídos37; 
ƒ Criação de asserções para validar os requisitos de performance e 
funcionalidade; 
ƒ Possibilidade de monitorar a performance de um servidor Apache 
Tomcat38; 
ƒ Permite a utilização de pré-processadores e pós-processadores para 
modificar o comportamento das requisições; 
ƒ Suporta diversos tipos de monitores para avaliar a performance da 
aplicação em teste; 
 
 
 
 
 
 
 
 
35 http://jakarta.apache.org/jmeter/index.html (os exemplos deste livro são apresentados 
com a versão 2.3RC3) 
36 http://en.wikipedia.org/wiki/HTTP 
37 http://jakarta.apache.org/jmeter/usermanual/jmeter_distributed_testing_step_by_step.pdf 
38 http://en.wikipedia.org/wiki/Apache_Tomcat 
 
110
Configurando um test plan 
 
Tão logo o JMeter seja instalado e configurado, a sua primeira ação deverá 
ser configurar um Test Plan. Todas as vezes que o JMeter é aberto um Test 
Plan em branco é exibido na sua janela principal. Por meio do Test Plan, você 
poderá definir parâmetros ou comportamentos comuns a todos os testes. 
 
Nesta janela, você também poderá configurar o nome do Test Plan, adicionar 
um comentário e criar variáveis que poderão ser compartilhadas por todos os 
testes. 
 
Por meio da opção “Run each Thread Group separately”, você poderá definir 
se os Thread Groups (grupos de usuários virtuais que simulam a navegação 
do seu site ou aplicação WEB) serão executados simultaneamente ou 
seqüencialmente, como pode ser observado na Figura 88. 
 
 
Figura 88: Configurando um Test Plan 
 
 
 
 
 
 
111
Adicionando e configurando um thread group 
 
O Thread Group representa os usuários virtuais que simulam a navegação do 
seu site ou aplicação WEB. Para adicionar um Thread Group, você deverá 
clicar com o botão direito do mouse sobre o Test Plan e escolher a opção de 
menu “Add>Thread Group”, como pode ser visto na Figura 89. 
 
 
Figura 89: Adicionando um Thread Group 
 
A janela “Thread Group” deverá ser exibida, como pode ser observado na 
Figura 90. Nesta janela, você poderá configuraro número de usuários virtuais 
simultâneos que serão simulados durante a execução do teste por meio do 
campo “Number of Threads (users)”. 
 
 
Figura 90: Configurando um Thread Group 
 
 
112
O campo “Ramp-Up Period” define a freqüência/tempo de lançamento dos 
usuários virtuais. Por exemplo, você poderá configurar 10 usuários virtuais 
(Number of Threads (users)) e definir um Ramp-Up period de 10 segundos. 
Neste cenário, um usuário virtual será lançado (iniciado) por segundo. Dessa 
forma, a partir do décimo segundo, todos os usuários virtuais estarão sendo 
executados simultaneamente. 
 
O campo “Loop Count” define quantas vezes o teste será repetido. Um Loop 
Count igual a 10 significa que o teste será executado por todos os usuários 
virtuais 10 vezes consecutivas. 
 
Por último, você poderá configurar um cronograma de execução por meio da 
seção “Scheduler Configuration”. Nesta seção você definirá a data e a hora 
de início e fim da execução dos testes, entre outras opções. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
113
Gravando um teste por meio de um HTTP Proxy 
 
Para gravar um teste, você deverá clicar com o botão direito do mouse sobre 
o item WorkBench (logo abaixo do Test Plan) e escolher a opção de menu 
“Add>Non-Test Elements>HTTP Proxy Server” para adicionar um HTTP Proxy 
Server. 
 
A janela “HTTP Proxy Server” deverá ser exibida, como pode ser observado 
na Figura 91. O propósito do HTTP Proxy server é capturar e gravar todas as 
requisições HTTP (GET, POST, etc) trocadas entre o navegador e o site ou 
aplicação WEB. 
 
 
Figura 91: Adicionando um HTTP Proxy Server 
 
Dessa forma, o JMeter poderá executar os testes por meio da reprodução das 
requisições HTTP gravadas neste passo. A princípio, você deverá manter 
todos os parâmetros default desta janela, exceto o campo “Target 
Controller”. Neste campo você deverá selecionar o Thread Group que você 
criou anteriormente. Assim, o HTTP Proxy Server saberá o lugar onde as 
requisições HTTP capturadas deverão ser gravadas. Lembre-se de pressionar 
o botão “Start” para iniciar o HTTP Proxy Server. 
 
Em seguida, você deverá apontar o Proxy do seu navegador preferido para o 
endereço “localhost:8080”. É neste endereço que o HTTP Proxy Server do 
JMeter está “escutando” as requisições. Dessa forma, o JMeter poderá 
capturar e gravar todas as requisições HTTP (GET, POST, etc) trocadas entre 
 
114
o navegador e a aplicação WEB, como pode ser visto no exemplo 
apresentado na Figura 92. 
 
 
Figura 92: Configurando o Proxy do navegador 
 
Assim que o Proxy do navegador for configurado, você poderá navegar no 
site ou utilizar a aplicação WEB normalmente, simulando a utilização de um 
usuário convencional. 
 
Ao final da navegação você deverá fechar o navegador e parar a execução do 
HTTP Proxy Server por meio do botão “Stop” (Figura 91). Você poderá notar 
que foram criados vários elementos abaixo do Thread Group. Esses 
elementos representam as requisições HTTP trocadas entre o navegador e o 
site ou aplicação WEB. 
 
Para fins didáticos e de entendimento, foi gravado uma pesquisa com as 
palavras chave “teste de software” no Google, como pode ser observado na 
Figura 93. 
 
 
115
 
Figura 93: Requisições HTTP 
 
Os testes poderão também ser criados manualmente por meio da adição e 
configuração manual das requisições HTTP (isso é necessário para testes 
cujas requisições sejam SSL/HTTPS39). 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
39 http://wiki.apache.org/jakarta-jmeter/JMeterAndHTTPS 
 
116
Adicionando asserções 
 
O Jmeter, por meio de“Assertions” (asserções), valida as respostas das 
requisições HTTP. Existe um conjunto de asserções para as mais diversas 
funções, mas por hora, vamos discutir um pouco sobre a asserção “Response 
Assertion”. 
 
Este tipo de asserção permite que você procure determinado texto dentro do 
conteúdo de uma requisição HTTP. Se o texto procurado não for encontrado, 
então a asserção falhará. 
 
Dando continuidade ao nosso exemplo de pesquisa no Google, você deverá 
clicar com o botão direito do mouse na requisição HTTP chamada “search” e 
escolher a opção de menu “Add>Assertions>Response Assertion”, como pode 
ser visto na Figura 94. 
 
 
Figura 94: Adicionando uma Response Assertion 
 
A asserção foi adicionada na requisição HTTP chamada “search” em virtude 
de que os resultados da pesquisa serão trazidos na resposta desta requisição. 
 
Na janela “Response Assertion”, você poderá configurar o nome da asserção, 
qual campo da resposta vai ser procurado, a regra de comparação e os 
textos a serem procurados na resposta. 
 
 
 
 
117
No nosso caso, vamos procurar o texto “Wikipédia” na resposta da 
requisição, como pode ser visto na Figura 95. 
 
 
Figura 95: Configurando uma Response Assertion 
 
Outra asserção interessante que vale a pena destacar chama-se “Duration 
Assertion”. Por meio dessa asserção você poderá validar se o tempo de 
resposta de uma requisição HTTP é maior do que um valor esperado. 
 
Para validar o tempo de resposta de todas as requisições HTTP associadas ao 
Thread Group, escolha a opção de menu “Add>Assertions>Duration 
Assertion”, como pode ser visto na Figura 96. 
 
 
 
Figura 96: Adicionando uma Duration Assertion 
 
 
Na Janela “Duration Assertion”, você deverá preencher o campo “Duration in 
miliseconds” para configurar o tempo de resposta limite para as requisições 
HTTP, como pode ser observado na Figura 97. 
 
Se alguma requisição demorar mais tempo do que o tempo limite definido na 
asserção, então a asserção falhará. 
 
 
118
 
Figura 97: Configurando uma Duration Assertion 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
119
Adicionando um timer 
 
Você poderá simular a navegação de um site ou utilização de uma aplicação 
WEB de maneira mais realística por meio da utilização de um Timer. 
 
Nenhum usuário normal clica nos links rapidamente milhares de vezes feito 
um robô. O Timer é um recurso do JMeter que permite a simulação das 
paradas para ler algum texto ou ver alguma figura que um usuário normal 
realiza antes de realizar a próxima operação. 
 
O JMeter oferece um conjunto de Timers para as mais diversas funções, mas 
por hora, vamos discutir um pouco sobre o “Uniform Random Timer”. Este 
tipo de Timer permite simular uma parada aleatório dentro dos limites inferior 
e superior que você informar. 
 
Para adicionar este Timer, você deverá clicar com o botão direito do mouse 
sobre o Thread Group e, em seguida, escolher a opção de menu 
“Add>Timer>Uniform Random Timer”. Neste caso, o Timer afetará todas as 
requisições HTTP que estiverem associadas a esse Thread Group. 
 
Na Janela “Uniform Random Timer”, você deverá preencher os campos 
“Random Delay Maximum” e “Constant Delay Offset” para definir os limites 
inferior e superior das paradas simuladas, como pode ser observado na 
Figura 98. 
 
 
Figura 98: Configurando um Timer 
 
 
 
 
 
 
 
120
Adicionando listeners (relatórios) 
 
Para visualizar os resultados dos testes de performance, durante ou após a 
execução dos testes, você deverá associar Listeners ao Thread Group ou ao 
Test Plan. O JMeter oferece vários Listeners para os exibir os mais diversos 
tipos de relatórios, como pode ser visto no exemplo apresentado na Figura 
99. Os Listeners capturam os dados das requisições durante a execução do 
teste e alimenta relatórios e gráficos indicando a performance da aplicação 
em teste. 
 
 
Figura 99: Adicionando Listeners 
 
Para não nos alongarmos muito, vamos apresentar apenas os Listeners mais 
importantes. Neste caso, você deverá selecionaro Thread Group e adicionar 
os seguintes Listeners: Assertion Results, Graph Results, Aggregate Graph, 
View Results Tree e Statistical Aggregate Report, como pode ser observado 
no exemplo apresentado na Figura 100. 
 
 
121
 
Figura 100: Listeners mais comuns 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
122
Executando e visualizando os resultados 
 
Tão logo você associe os Listeners ao Thread Group, o próximo passo será 
executar o teste. Para realizar tal tarefa, você deverá acessar o menu 
“Run>Start” e aguardar a finalização da execução do teste. Caso você queira 
cancelar o teste durante a sua execução, acesse o menu “Run>Stop”. 
 
O JMeter também oferece a possibilidade de executar os testes por meio da 
linha de comando ou por meio de uma tarefa do ANT40. 
 
Em tempo, devemos lembrar que todos os Listeners permitem que os dados 
sejam exportados para serem manipulados e exibidos por alguma outra 
ferramenta (planilha eletrônica, por exemplo). 
 
 
Figura 101: Visualizando o Listener Assertion Results 
 
Ao final ou durante a execução dos testes você poderá visualizar os 
resultados obtidos pelos Listeners. Na Figura 101 você poderá observar o 
resultado do Listener Assertion Results. Neste caso, somente as requisições 
HTTP que não atenderam os parâmetros das asserções (Response e 
Duration) são listadas neste relatório. 
 
Por outro lado, o Listener Graph Results desenha um gráfico descrevendo o 
desvio padrão, a média, a taxa de requisições realizadas por segundo, entre 
outras informações, como pode ser observado na Figura 102. 
 
 
40 http://www.programmerplanet.org/pages/projects/jmeter-ant-task.php 
 
123
 
Figura 102: Visualizando o Listener Graph Results 
 
Em contrapartida, o Listener Aggregate Graph exibe as estatísticas para cada 
página individualmente, como pode ser observado na Figura 103. 
 
 
Figura 103: Visualizando o Listener Aggregate Graph 
 
O Listener View Results Tree, por sua vez, nos fornece informações sobre o 
código de sucesso ou falha das requisições HTTP (HTTP Response Code41), 
assim como o conteúdo completo das requisições. 
 
41 http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html 
 
124
Desta forma, você poderá visualizar exatamente o que navegador teria 
recebido caso um usuário real estivesse navegando no site ou aplicação WEB, 
como pode ser observado no exemplo apresentado na Figura 104. 
 
 
Figura 104: Visualizando o Listener View Results Tree 
 
Por fim, o Listener Statistical Aggregate Report apresenta a relação entre o 
tempo de resposta e a quantidade de requisições realizadas por segundo ao 
longo do tempo, como pode ser observado na Figura 105. 
 
Devemos lembrar que esse Listener não faz parte do pacote original do 
JMeter. Na verdade este Listener é um plug-in e deve ser instalado 
separadamente42. 
 
 
Figura 105: Visualizando o Listener Statistical Aggregate Report 
 
42 http://rubenlaguna.com/wp/better-jmeter-graphs/ 
 
125
Monitorando a performance do servidor 
O JMeter, por ser uma ferramenta Open Source do grupo Apache, oferece 
uma forte integração com o Apache Tomcat. 
 
 
Figura 106: Adicionando um HTTP Authorization Manager 
 
Na verdade, o JMeter oferece um recurso onde você poderá monitorar a 
performance do Apache Tomcat durante a execução dos testes de 
performance (caso o seu site ou aplicação WEB esteja sendo executada no 
Tomcat). 
 
No entanto, para configurar esse recurso, você deverá seguir alguns passos 
conforme indicaremos a seguir. Em primeiro lugar, você deverá criar um novo 
Thread Group. Vamos chamá-lo de “Monitor do Tomcat”. Neste Thread 
Group, adicione um HTTP Authorization Manager por meio do menu 
“Add>Config Element>HTTP Authorization Manager”. 
 
Na janela “HTTP Authorization Manager” você deverá adicionar a URL raiz do 
seu servidor Apache Tomcat, assim como, o usuário e a senha do 
administrador. A principal função do Authorization Manager é fornecer as 
credenciais necessárias para obter os parâmetros de performance do Apache 
Tomcat, como pode ser observado no exemplo apresentado na Figura 107. 
 
 
126
 
Figura 107: Configurando o HTTP Authorization Manager 
 
Uma vez que o HTTP Authorization Manager for configurado, você deverá 
adicionar ao Thread Group “Monitor do Tomcat” um HTTP Request. Para 
realizar tal tarefa, clique com o botão direito do mouse no Thread Group 
“Monitor do Tomcat” e acesse o menu “Add>Sampler>HTTP Request”. 
 
O HTTP Request tem a função de enviar requisições ao servidor Apache 
Tomcat para obter os parâmetros de performance durante a execução dos 
testes. Na janela “HTTP Request” você deverá configurar o IP do servidor 
Apache Tomcat, assim como, a porta em que o servidor estiver escutando. 
 
Adicionalmente, na seção “HTTP Request você deverá informar o caminho 
“/manager/status” para indicar o lugar onde os parâmetros de performance 
deverão ser obtidos. 
 
Por último, na seção “Send Parameters with the Request”, você deverá 
preencher os campos “Name” e “Value” com os valores “XML” e “true” 
respectivamente. Lembre-se de habilitar o campo “Use as Monitor” localizado 
na seção “Optional Tasks”, como pode ser observado na Figura 108. 
 
 
127
 
Figura 108: Configurando o HTTP Request 
 
Tão logo o HTTP Request seja configurado, você deverá adicionar um 
Constant Timer ao Thread Group “Monitor do Tomcat” por meio do menu 
“Add>Timer>Constant Time”. Na janela “Constant Timer”, configure o Timer 
de maneira que ele simule uma parada de 5 segundos por meio do campo 
“Thread Delay”. 
 
Dessa forma, você evitará que sejam enviadas centenas de requisições por 
segundo para verificar os parâmetros de performance do Tomcat. Neste caso, 
o Timer garantirá que será enviada uma requisição a cada 5 segundos, como 
pode ser visto na Figura 109. 
 
 
128
 
Figura 109: Configurando um Constant Timer 
 
Por fim, o último passo deverá ser realizado por meio da adição de um 
Listener chamado “Monitor Results”. Para realizar tal tarefa, clique com o 
botão direito do mouse sobre o Thread Group “Monitor do Tomcat” e 
selecione a opção de menu “Add>Listener>Monitor Results”. 
 
Na aba “Health” da janela Monitor Results, você poderá acompanhar a 
“saúde” do Tomcat por meio de indicadores coloridos durante a execução dos 
testes de performance, como pode ser observado no exemplo apresentado 
na Figura 110. 
 
 
Figura 110: Monitorando a saúde do Tomcat 
 
 
129
Por outro lado, na aba “Performance” da janela Monitor Results, você poderá 
acompanhar a performance e utilização de recursos do Apache Tomcat 
durante a execução dos testes de performance, como pode ser visto na 
Figura 111. 
 
 
Figura 111: Monitorando a performance do Tomcat 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
130
Microsoft WEB Application Stress 
 
O Microsoft WEB Application Stress (WAS)43 é uma ferramenta gratuita para 
Windows. Por meio do WAS, você poderá realizar testes de performance, 
volume e estresse nas suas aplicações WEB. 
 
O WAS é uma ferramenta pobre em recursos, se compararmos com o JMeter, 
no entanto ela tem um perfil do tipo "pau para toda obra" para testes 
rápidos. 
 
Os testes podem ser escritos manualmente (por meio da criação manual das 
requisições HTTP (GET, POST, etc)) ou gravados automaticamente enquanto 
você navega na aplicação simulando um usuário real (por meio de um Proxy 
Server). 
 
Entre os diversos recursos oferecidos pelo WAS, devemos destacar a 
possibilidade de executar os testes em computadores distribuídos, a 
configuração fina do comportamento do teste de performance e a 
possibilidadede monitorar a utilização dos recursos dos servidores Windows 
(apenas no Windows 2000 e NT). 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
43 http://www.microsoft.com/downloads/details.aspx?FamilyID=e2c0585a-062a-439e-a67d-
75a89aa36495&DisplayLang=en (os exemplos deste livro são apresentados com a versão 
1.0) 
 
131
 
Gravando um teste por meio de um HTTP Proxy 
 
Para gravar um teste, você deverá clicar no ícone “New Script” da barra de 
ferramenta do WAS. O diálogo “Create new Script” deverá ser exibido, como 
pode ser visto na Figura 112. 
 
Por meio desse diálogo você poderá escolher como o teste será criado. O 
WAS permite que você crie um teste de performance por meio dos seguintes 
mecanismos: 
 
ƒ Manual: Você deverá inserir manualmente as requisições HTTP 
(GET, POST, etc) trocadas entre o navegador e o servidor da 
aplicação WEB; 
 
ƒ Record: O WAS cria o teste automaticamente por meio da gravação 
das requisições HTTP (GET, POST, etc) trocadas entre o navegador 
e o servidor da aplicação WEB (utilizando um Proxy); 
 
ƒ Log file: O WAS cria o teste automaticamente com base nas 
informações de um arquivo de log do IIS44; 
 
ƒ Content: O WAS cria o teste automaticamente com base na leitura 
dos arquivos (HTML) e diretórios do site ou aplicação WEB; 
 
 
 
44 http://en.wikipedia.org/wiki/Internet_Information_Services 
 
132
Figura 112: Gravando um teste por meio de um HTTP Proxy 
 
Por hora, vamos nos concentrar no mecanismo de gravação utilizando um 
Proxy. Na janela “Create new script”, selecione a opção “Record”. O diálogo 
“Browser Recorder” deverá ser exibido, conforme pode ser observado na 
Figura 113. 
 
 
Figura 113: Browser Recorder 
 
Neste diálogo, entre outras configurações, você poderá optar pela gravação 
do tempo que você levar para ler algum texto ou ver alguma figura antes de 
realizar a próxima requisição (atraso ou parada), simulando assim um usuário 
real durante a execução dos testes de performance. 
 
Deixe os valores default nos campos e pressione o botão “Next>”. Uma 
janela do Internet Explorer pré-configurada com o endereço do Proxy abrirá 
automaticamente, como pode ser visto na Figura 114. 
 
 
Figura 114: Gravando um teste por meio de um proxy 
 
 
133
Nesta janela digite o endereço do seu site ou aplicação WEB e comece a 
navegar como se fosse um usuário comum. O HTTP Proxy do WAS captura e 
grava todas as requisições HTTP (GET, POST, etc) trocadas entre o 
navegador e a aplicação WEB. Dessa forma, o WAS poderá executar os testes 
por meio da reprodução das requisições HTTP gravadas neste passo, como 
pode ser observado na Figura 115. 
 
 
Figura 115: Gravando as requisições HTTP 
 
Tão logo você conclua a navegação, feche o Internet Explorer e pressione o 
botão “Stop Recording” da janela “Recording” (Figura 115). 
 
 
Figura 116: New Recorded Script 
 
Todas as requisições gravadas serão automaticamente associadas a um novo 
teste chamado “New Recorded Script”. Neste novo teste, você verá as 
requisições HTTP gravadas, o tipo de requisição, o tempo de atraso (delay), 
entre outras informações. 
 
134
 
É importante lembrar que, por padrão o WAS atribuirá o valor “localhost” no 
campo Server. Para que o teste seja executado posteriormente com sucesso, 
você deverá modificar este valor para o endereço correto do seu servidor 
WEB. 
 
Para fins didáticos e de entendimento, foi gravado uma pesquisa com as 
palavras chave “teste de software” no Google. 
 
O WAS também permite que você modifique qualquer parâmetro da 
requisição HTTP. Para tal tarefa, dê um duplo clique em qualquer requisição 
HTTP gravada no seu teste. A janela com os dados da requisição deverá ser 
exibida, como pode ser observado no exemplo apresentado na Figura 117. 
 
 
Figura 117: Modificando uma requisição HTTP 
 
 
 
 
 
 
 
 
 
 
 
 
 
135
Executando e visualizando os resultados 
 
Para executar o teste de performance, você deverá acessar o menu 
“Scripts>Run” e aguardar a finalização da execução do teste, como pode ser 
visto na Figura 118. Caso você queira cancelar o teste durante a sua 
execução, pressione o botão “Stop Test”. 
 
 
Figura 118: Executando o teste 
 
Ao final da execução dos testes você poderá visualizar o status da 
performance da sua aplicação WEB por meio de diversos relatórios. Para abrir 
a janela de relatórios, acesse o menu “View>Reports”. A janela “Reports” 
deverá ser exibida. 
 
Por meio do relatório “Overview”, você poderá ter uma visão geral dos 
principais indicadores de performance do teste selecionado (Figura 119). 
 
 
Figura 119: Visualizando o resultado geral dos testes 
 
136
O relatório “Result Codes” nos fornece informações sobre o código de 
sucesso ou falha das requisições HTTP (HTTP Response Code45) (Figura 120). 
 
 
Figura 120: Visualizando o relatório Result Codes 
 
O relatório “Page Summary”, por sua vez, exibe o tempo médio de resposta 
de cada requisição HTTP (Figura 121). 
 
 
Figura 121: Visualizando o relatório Page Summary 
 
 
 
 
 
 
 
 
 
 
45 http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html 
 
137
Configurando o comportamento dos testes 
 
Você poderá configurar o comportamento do teste de performance por meio 
da janela “Settings”. Nesta janela, você poderá configurar a quantidade de 
usuários concorrentes na seção “Concurrent Connections”. Para ajustar o 
limite de tempo da execução dos testes, utilize o campo “Test Run Time”. 
 
Se no momento da captura das ações você não ativou a gravação do tempo 
de parada entre as requisições (Record delay between requests), você 
poderá configurar paradas randômicas na seção “Request Delay” ou um 
intervalo fixo de tempo, como pode ser observado na Figura 122. 
 
Dentre as outras configurações possíveis, devemos ressaltar a possibilidade 
de configurar períodos de tempo onde os resultados dos testes não serão 
registrados nos relatórios (início “Warmup” e no final “Cooldown”). E, por 
último, você também poderá simular a execução de testes em diversas 
larguras de bandas na seção “Bandwidth”. 
 
 
 
Figura 122: Configurando o comportamento dos testes 
 
 
 
 
138
Configurando Page Groups 
 
Para evitar que as requisições sejam feitas de maneira homogênea durante a 
execução dos testes, você poderá organizar logicamente a distribuição das 
requisições por meio da configuração de Page Groups. 
 
Dessa forma, você garantirá que uma quantidade maior de requisições será 
realizada em determinada funcionalidade ou página de acordo com a 
utilização da aplicação WEB na vida real. 
 
Para realizar a configuração dos Page Groups, você deverá abrir a janela 
“Page Groups”, como pode ser visto na Figura 123. Nesta janela, você poderá 
adicionar os grupos e o percentual de distribuição em que as requisições 
pertencentes a esses grupos serão executadas ao longo do teste. 
 
Neste cenário, vamos adicionar um novo grupo chamado “pesquisa” e 
configurar um percentual de 25% de distribuição a esse grupo. 
 
 
Figura 123: Configurando Page Groups 
 
Uma vez que os Page Groups sejam configurados, você deverá associar as 
requisições HTTP ao Page Group conforme a sua necessidade. No nosso 
caso, vamos associar o Page Group “pesquisa” à requisição que realiza a 
pesquisa pelas palavras chaves “teste de software”, como pode ser 
observado na Figura 124. 
 
 
139
 
Figura 124: Associando um Page Group a uma requisição 
 
Ao final da execução dos testes você poderá visualizar o relatório das 
requisições distribuídas por grupo na seção “Page Groups” da janela 
“Reports”, como podeser observado na Figura 125. 
 
 
Figura 125: Relatórios das requisições distribuídas por grupo 
 
 
 
 
 
 
140
Configurando usuários para autenticação 
 
Por meio da janela Users, você poderá adicionar usuários e as suas 
respectivas senhas caso seja exigido pela sua aplicação WEB ou site. Para 
adicionar usuários, você deverá clicar no ícone “Users” da barra de 
ferramenta do WAS. 
 
A janela “Users” deverá ser exibida, como pode ser visto na Figura 126. 
Nesta janela você poderá criar usuários e grupos de usuários manualmente 
ou por meio da importação dos dados de um arquivo externo. 
 
 
Figura 126: Adicionando usuários para a autenticação 
 
Uma vez que os grupos sejam criados e os usuários adicionados, você poderá 
associar ao teste um ou mais grupos de acordo com as suas necessidades 
por meio da opção “Users”, como pode ser observado na Figura 127. 
 
 
 
Figura 127: Associado grupos de usuários ao teste 
 
 
141
Capítulo 6 • Controle de versões 
 
 
A qualidade de um projeto de software é diretamente proporcional a 
qualidade dos processos adotados nas diversas fases do seu ciclo de vida. O 
controle de versões é visto como uma extensão natural do processo de 
desenvolvimento, permitindo que se possa paralelizar o desenvolvimento de 
forma coerente e padronizada. 
 
Por essa razão, sem uma ferramenta ou metodologia adequada, esse 
controle torna-se extremamente complexo e improdutivo. Neste cenário, é 
necessária a utilização de uma ferramenta que atenda os pré-requisitos 
básicos de um processo de Gerência de Configuração de Software e 
implemente as principais funções pertinentes ao controle de versões. 
 
Em geral, ferramentas de controle de versões devem fornecer uma 
abordagem consistente, controlada e flexível para gerenciar a evolução das 
mudanças, garantindo a integridade e a rastreabilidade dos arquivos 
modificados. 
 
Adicionalmente, estas ferramentas devem oferecer mecanismos capazes de 
controlar os acessos simultâneos e as modificações paralelas, garantindo a 
integridade das modificações e a atomicidade das operações. 
 
Na tabela abaixo você poderá ver a ferramenta que será apresentada nas 
próximas seções: 
 
Tortoise 
CVS 
 
http://www.tortoisecvs.org/ 
 
 
 
 
 
 
 
 
 
 
 
142
CVS 
 
O CVS46 é uma ferramenta Open Source que atende os pré-requisitos básicos 
de um processo de Gerência de Configuração de Software47 e implementa as 
principais funções pertinentes ao controle de versões. 
 
Basicamente, o CVS armazena em seu repositório as modificações realizadas 
num arquivo ao longo do tempo; cada modificação é identificada por um 
número chamado Revisão. 
 
Toda Revisão armazena as modificações realizadas, quem realizou as 
modificações, quando as modificações foram realizadas, entre outras 
informações. 
 
Além disso, o CVS conta com um mecanismo capaz de controlar os acessos 
simultâneos e as modificações paralelas, garantindo a integridade das 
modificações e a atomicidade das operações. 
 
De maneira geral, o fluxo de trabalho básico do CVS consiste em retirar os 
arquivos de um projeto para a área de trabalho, realizar as modificações e, 
por último, submeter as modificações de volta ao repositório, como pode ser 
visto na Figura 128. O completo entendimento dos termos apresentados na 
Tabela 3 é fundamental para auxiliar a leitura desse capítulo. 
 
 
46 http://ximbiot.com/cvs/manual/ 
47 Gerência de Configuração Técnicas e Práticas no Desenvolvimento do Software 
 
143
 
Figura 128: Operações realizadas pelo CVS 
 
Termo Descrição 
Workspace, SandBox 
(Área de trabalho) 
Termo usado para representar um diretório no 
computador cliente onde os arquivos de um projeto 
serão transferidos durante uma retirada. 
Repository 
(Repositório) 
Local onde os arquivos submetidos ao controle de 
versões são armazenados. 
 
Revision (Revisão) Termo usado para descrever a numeração atribuída 
pelo CVS a cada modificação de um arquivo. 
Release, Version 
(Liberação) 
Termo usado para descrever a denominação 
atribuída a um conjunto de arquivos para 
identificar determinado ponto no tempo; 
sobretudo, quando se quer identificar um conjunto 
de novas características ou correções de um 
software. 
Commit (Entregar, 
Submeter) 
Termo usado para descrever a transferência de um 
ou mais arquivos modificados da área de trabalho 
para um repositório. 
Checkout (Retirar, 
Recuperar) 
Termo usado para descrever a retirada de um ou 
mais arquivos de um repositório para a área de 
 
144
trabalho. 
Diff (Comparação das 
diferenças) 
Termo usado para descrever o processo de 
comparação das modificações entre revisões 
diferentes de um arquivo. 
Import (Importação) Termo usado para descrever o processo de 
transferência dos arquivos de um projeto a um 
repositório, dando inicio ao controle de versões. 
Module (Projeto, 
Módulo) 
Termo usado para descrever um nome simbólico 
associado a um conjunto de diretórios e arquivos 
que compõem um projeto a fim de facilitar o 
acesso e a manipulação. 
Branch (Ramo) Termo usado para descrever o processo de divisão 
dos arquivos de um projeto em linhas de 
desenvolvimento independentes. 
Tabela 3: Termos utilizados no controle de versões 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
145
TortoiseCVS 
 
O TortoiseCVS48 é um front-end gráfico Open Source para Windows que 
torna o uso do CVS mais fácil e intuitivo. Basicamente, o TortoiseCVS realiza 
as principais operações do CVS por meio de menus de contexto integrados ao 
Windows Explorer, como pode ser visto na Figura 129. 
 
 
Figura 129: Menus de contexto integrados ao Windows Explorer 
 
O TortoiseCVS é, em virtude da sua proposta, uma ferramenta extremamente 
eficiente cuja principal característica é a sua independência de uma aplicação 
cliente específica. Dessa forma, como descrito anteriormente, todas as 
operações serão realizadas por meio de menus de contexto do Windows 
Explorer. O TortoiseCVS suporta as seguintes versões do Windows: Windows 
95, 98, ME, NT, 2000 e XP. 
 
 
 
 
 
 
 
 
48 http://www.tortoisecvs.org/ (os exemplos deste livro são apresentados com a versão 
1.8.29) 
 
146
Repositório 
 
Basicamente, um repositório é um diretório que tem por objetivo abrigar 
todos os arquivos de um projeto sob o controle de versões. O repositório 
poderá ser criado num diretório compartilhado no seu computador ou num 
servidor (Windows49 50 ou Linux51). 
 
Naturalmente, quando o repositório é criado num servidor, você deverá 
instalar um servidor de CVS e configurar um método de acesso ao repositório 
para garantir a segurança dos arquivos sob o controle de versões. 
 
Sendo assim, para fins didáticos, os exemplos apresentados nas seções 
seguintes serão realizados num repositório local. Para tal tarefa, você deverá 
criar e compartilhar um diretório chamado CVSROOT na raiz do seu 
computador (C:\CVSROOT). 
 
Importação 
 
Uma vez que o repositório tenha sido criado, o primeiro passo para iniciar o 
controle de versões é chamado de Importação. Neste passo, os arquivos da 
sua aplicação são transferidos para o repositório e submetidos ao controle de 
versões do CVS. 
 
Para tal tarefa, vamos transferir os arquivos de uma aplicação exemplo para 
o diretório "C:\Temp". A importação do projeto deverá ser realizada por meio 
do menu de contexto “Make New Module”. 
 
Na caixa de diálogo “Make New Module”, o TortoiseCVS fornece opções para 
acessar repositórios remotos por meio de qualquer método de autenticação 
suportado pelo CVS. Mas, no entanto, como havíamos definido 
anteriormente, todos os exemplos serão realizadosutilizando um repositório 
local. 
 
Em razão disso, você deverá selecionar a opção “Locally mounted folder 
(:local:)” no campo “Protocol”. O campo "Repository folder" deverá ser 
preenchido com "C:\CVSROOT" que é a localização do repositório criado 
anteriormente na raiz do seu computador. 
 
 
49 http://www.march-hare.com/cvspro/ 
50 http://www.devguy.com/fp/cfgmgmt/cvs/cvs_admin_nt.htm 
51 http://devguy.com/fp/cfgmgmt/cvs/cvs_admin_linux.htm 
 
147
O campo Módulo indica um apelido que será utilizado pelo TortoiseCVS todas 
as vezes que ele se referir ao nosso projeto e deverá ser preenchido com o 
texto “webapp”, como pode ser visto na Figura 130. 
 
 
Figura 130: Caixa de diálogo para criar um novo módulo 
 
Após confirmar os dados anteriores, o TortoiseCVS exibirá um diálogo 
informando que não existe nenhum repositório criado no diretório informado. 
Você deverá selecionar a opção “Initialise a new repository here” para 
inicializar um novo repositório, como pode ser observado na Figura 131. 
 
 
Figura 131: Inicialização do repositório 
 
148
Este diálogo será exibido somente quando importar o primeiro projeto. Assim 
que a criação do novo módulo e a inicialização do repositório finalizarem, 
você deverá adicionar os arquivos a esse módulo recém criado. 
 
Para tal tarefa, você deverá acessar o menu de contexto “CVS Add Contents”. 
O TortoiseCVS exibirá um diálogo solicitando a confirmação dos arquivos que 
serão adicionados, como pode ser visto na Figura 132. 
 
Figura 132: Adicionando arquivos ao módulo 
 
Por fim, devemos realizar a operação de entrega, também chamada de 
“Commit” para transferir os arquivos do projeto “webapp” definitivamente 
para o repositório do CVS. 
 
Essa operação deverá ser realizada através do menu de contexto “CVS 
Commit”. O TortoiseCVS exibirá um diálogo solicitando a confirmação dos 
arquivos que serão transferidos para o repositório. 
 
Neste diálogo você também deverá escrever um breve comentário 
descrevendo as modificações realizadas. Além disso, antes de confirmar a 
operação você poderá modificar o formato do arquivo, comparar as suas 
modificações com outras versões armazenadas no repositório, entre outras 
opções, como pode ser observado na Figura 133. 
 
 
149
 
Figura 133: Transferência definitiva dos arquivos para repositório CVS 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
150
Retirada dos arquivos do repositório 
 
Uma vez que os arquivos de um projeto forem importados com sucesso, 
podemos finalmente iniciar as operações de controle de versões. Para tal 
tarefa, devemos retirar os arquivos armazenados no repositório e transferi-los 
para a área de trabalho onde serão realizadas as modificações nos arquivos 
do projeto. 
 
A área de trabalho é um diretório qualquer no seu disco rígido. Neste caso, 
vamos assumir que a nossa área de trabalho será o diretório “C:\Projetos”. 
Para retirar os arquivos você deverá clicar com o botão direito sobre o 
diretório “C:\Projetos” e acessar o menu de contexto “CVS Checkout”. Como 
resultado, o TortoiseCVS exibirá o diálogo para realizar a retirada dos 
arquivos, também conhecido como “Checkout”. Por meio desse diálogo, você 
poderá configurar onde está localizado o repositório de arquivos, qual projeto 
você deseja retirar, entre outras opções, como pode ser visto na Figura 134. 
 
 
Figura 134: Retirada dos arquivos do repositório CVS 
 
Por fim, assim que a operação de retirada for concluída, você poderá 
começar a trabalhar com os arquivos do projeto “webapp” que foram 
transferidos para o diretório “C:\Projetos\webapp”. 
 
 
 
151
Modificando os arquivos 
 
Assim que o projeto for transferido para a área de trabalho, poderemos 
iniciar a edição dos arquivos. Perceba que, após a importação e durante a 
edição dos arquivos, o TortoiseCVS modifica os ícones do Windows Explorer a 
fim dar um significado visual sobre o status dos arquivos da área de trabalho 
em relação aos arquivos armazenados no repositório, como pode ser visto na 
Figura 135. 
 
 
Figura 135: Ícones modificados indicando o status atual dos arquivos 
 
Para que a adição e remoção de arquivos sejam entendidas e refletidas no 
repositório do CVS, você deverá selecionar o arquivo desejado e acessar os 
menus de contexto “CVS Add” ou “CVS Remove” como descrito na Figura 
136. 
 
 
 
152
 
Figura 136: Adicionando e removendo arquivos 
 
Por fim, devemos realizar a operação de entrega “Commit” ao final do nosso 
trabalho para garantir que todas as modificações, adições e remoções sejam 
definitivamente refletidas no repositório do CVS. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
153
Inspecionando as modificações ao longo do tempo 
 
Repare que o menu de contexto “History” tem a função de apresentar o 
histórico das modificações realizadas num arquivo. Por meio desse recurso 
você poderá consultar o log das modificações, o nome do usuário que 
realizou a modificação, quando a modificação foi realizada e comparar a 
revisão atual com revisões antigas, como pode ser visto na Figura 137. 
 
 
Figura 137: Histórico das modificações ao longo do tempo 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
154
Configurando o TortoiseCVS 
 
Por último, o comportamento e as configurações do TortoiseCVS podem ser 
modificados por meio do menu de contexto “Preferences”, como pode ser 
visto na Figura 138. 
 
Dentre as configurações possíveis, podemos destacar: integração com 
ferramentas externas para a realização da comparação das diferenças entre 
duas revisões, modificação da aparência dos ícones que indicam o status dos 
arquivos no Windows Explorer e a opção para ignorar arquivos durante as 
operações do CVS (para evitar que determinados tipos de arquivos sejam 
submetidos ao controle de versões inadvertidamente). 
 
 
Figura 138: Preferências do TortoiseCVS 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
155
Capítulo 7 • Ferramentas de apoio 
 
 
À medida que se queira executar os testes de uma aplicação com maior 
eficiência, torna-se necessário estar familiarizado com a maior gama de 
ferramentas que possam auxiliar a simular um componente de hardware ou 
software que não esteja disponível, observar o tráfego da rede, entre outros 
cenários; as situações são ilimitadas, tudo depende do tipo de aplicação que 
está sendo testada. 
 
Perceba que não estamos falando de ferramentas para a automação de 
testes, apesar de que muitas delas podem automatizar a execução de 
algumas tarefas, mas a idéia principal é utilizar essas ferramentas para 
maximizar a eficiência dos testes manuais. 
 
Considerando o que foi exposto, devemos afirmar que o testador deve 
otimizar a execução dos testes ao máximo por meio do emprego de 
ferramentas ou, se for necessário, utilizar as suas habilidades de 
programação para escrever a sua própria ferramenta. 
 
Na tabela abaixo você poderá ver as ferramentas que serão apresentadas nas 
próximas seções: 
 
Tail for Win32 http://tailforwin32.sourceforge.net/ 
HeavyLoad http://www.jam-software.com/freeware/index.shtml 
Process Explorer http://www.microsoft.com/technet/sysinternals/ 
VMWARE http://www.vmware.com/products/server/ 
Microsoft PICT http://download.microsoft.com/download/f/5/5/f55484df-
8494-48fa-8dbd-8c6f76cc014b/pict33.msi 
Burp Suite http://portswigger.net/proxy/download.html 
Camstudio http://sourceforge.net/projects/camstudio/ 
MWSnap http://www.mirekw.com/winfreeware/mwsnap.html 
WinMerge http://winmerge.sourceforge.net/ 
Data Generator http://www.generatedata.com/ 
Firebug http://getfirebug.com/ 
 
 
 
 
 
 
 
 
 
156
Tail for Win32 
 
O Tail forWin3252 é um utilitário Open Source para Windows cuja principal 
função é exibir as últimas linhas de um arquivo. Você também poderá realizar 
a visualização dinâmica do arquivo à medida que novas linhas são inseridas. 
 
Esta funcionalidade é extremamente útil quando se quer durante a realização 
de um teste acompanhar algum arquivo de log para identificar exceções ou 
avisos, ou mesmo acompanhar algum arquivo de saída gerado pela aplicação 
em teste. 
 
No entanto, o Tail for Win32 não se limita a apenas a exibir as últimas linhas 
dos arquivos dinamicamente; você poderá adicionar uma lista de palavras 
chaves (keywords) e associar uma cor para cada palavra chave. Durante a 
exibição das linhas de um arquivo, o Tail for Win32 muda a cor do texto que 
corresponder as palavras chaves existentes. Além disso, você poderá 
configurar o Tail for Win32 para hachurar as linhas que contém palavras 
chaves, soar um bipe quando o arquivo for modificado, exibir somente as 
linhas que corresponderem as palavras chaves cadastras ao invés de mostrar 
todas as linhas, entre outras configurações, como pode ser visto no exemplo 
apresentado na Figura 139. 
 
 
 
Figura 139: Tail for Win32 
 
Caso o Tail for Win32 não atenda as suas necessidades, vale a pena conferir 
os utilitários BareTail53 e MakeLogicTail54 que oferecem funcionalidades 
semelhantes. 
 
52 http://tailforwin32.sourceforge.net/ 
53 http://www.baremetalsoft.com/baretail/ 
54 http://sourceforge.net/projects/makelogictail/ 
 
157
HeavyLoad 
 
O HeavyLoad55 é um utilitário gratuito para Windows cuja principal função é 
estressar os recursos de um computador, ou seja, aumentar a utilização do 
processamento, memória, disco, rede e sistema operacional a níveis 
extremamente elevados. 
 
O HeavyLoad foi criado originalmente para testar a robustez de servidores 
antes de entrar em produção, no entanto, podemos usá-lo para testar a 
confiabilidade e robustez da aplicação em teste quando submetida a um 
ambiente onde os recursos estão sendo utilizados no limite da sua 
capacidade. A utilização do HeavyLoad é bastante simples, basta selecionar 
quais recursos você quer estressar, qual freqüência será atualizado o gráfico 
que demonstra a utilização da memória e processamento e, por fim, iniciar a 
execução, como pode ser visto na Figura 140. 
 
 
Figura 140: HeavyLoad 
 
Caso o HeavyLoad não atenda as suas necessidades, vale a pena conferir o 
TrafficEmulator56 que oferece funcionalidades específicas para estressar 
redes, roteadores, firewalls, etc. 
 
55 http://www.jam-software.com/freeware/index.shtml 
56 http://www.nsauditor.com/network_tools/network_traffic_generator.html 
 
158
Process Explorer 
 
O Process Explorer57 é utilitário gratuito para Windows cuja principal função é 
monitorar a performance e o comportamento das aplicações. O 
funcionamento do Process Explorer é semelhante ao Gerenciador de Tarefas 
do Windows, mas no entanto, ele conta com diversos recursos avançados 
que nos auxilia a monitorar o comportamento e performance da aplicação em 
teste. 
 
Por meio do Process Explorer, você poderá ver informações da aplicação em 
teste, tais como, a linha de comando e o usuário usado para executar a 
aplicação, os processos filhos iniciados pela aplicação, entre outras 
informações. Devemos destacar também a possibilidade de visualizar os 
recursos, tais como, os arquivos, diretórios, chaves de registros e DLLs que 
foram abertos pela aplicação em teste. Além disso, você poderá ver também 
gráficos destacando a utilização de processamento, memória e disco apenas 
da aplicação selecionada, como pode ser observado no exemplo apresentado 
na Figura 141. 
 
 
Figura 141: Process Explorer 
 
É importante ressaltar que o Process Explorer faz parte de um pacote de 
ótimos utilitários chamado SysInternals58 da Microsoft que fazem a diferença 
durante as atividades de monitoração (profiling) da aplicação em teste. 
 
57 http://www.microsoft.com/technet/sysinternals/SystemInformation/ProcessExplorer.mspx 
58 http://www.microsoft.com/technet/sysinternals/default.mspx 
 
159
VMWARE 
 
O VMWARE59 é uma ferramenta gratuita que executa múltiplos sistemas 
operacionais ao mesmo tempo num mesmo computador físico por meio de 
virtualização. O VMWARE suporta a virtualização de diversas plataformas, tais 
como Windows, Linux, Novel Netware, Solaris, entre outros. Além disso, ele 
pode ser executado tanto no Windows quanto no Linux. 
 
O VMWARE é uma solução perfeita economizar investimentos com hardware 
quando é necessário testar aplicações que suportam plataformas diferentes. 
É importante lembrar que o sistema operacional virtualizado se comporta 
realmente como se fosse um ambiente separado do ambiente onde ele está 
sendo executado, mas no entanto, apesar dessas vantagens, o VMWARE não 
é recomendado para a realização de testes de performance, em virtude de 
que por mais eficiente que seja a virtualização, ela nunca será tão rápida 
quanto o hardware real. Dentre as principais funcionalidades do VMWARE, 
devemos destacar a possibilidade de executar vários sistemas operacionais ao 
mesmo tempo, a possibilidade de realizar configurações nos dispositivos 
virtualizados (memória, disco, rede, USB, entre outros), assim como, a 
possibilidade de salvar o estado do sistema operacional (snapshot) para 
posterior restauração (normalmente utilizado para voltar a determinado 
ponto no tempo em que o sistema operacional está limpo e com as pré-
condições necessárias satisfeitas para iniciar os testes), como pode ser visto 
na Figura 142. 
 
 
Figura 142: VMWARE 
 
É importante ressaltar que a Microsoft oferece um produto gratuito similar ao 
VMWARE chamado VirtualPC60. 
 
59 http://www.vmware.com/products/server/ e http://www.vmware.com/products/player/ 
60 http://www.microsoft.com/windows/products/winfamily/virtualpc/default.mspx 
 
160
Microsoft Pairwise Independent Combinatorial 
Testing 
 
O PICT61 é um utilitário gratuito para Windows cuja função principal é gerar 
uma lista de combinações baseadas no método de combinação dupla 
(pairwise). Muitas vezes, testar todas as combinações dos parâmetros de 
entrada ou pré-condições de um caso de teste é praticamente impossível em 
virtude do número elevado de cenários. Por meio do método de combinação 
dupla, cada par de parâmetros é combinado ao menos uma vez, garantindo 
dessa forma, uma cobertura mínima das situações possíveis. O PICT é 
executado pela linha de comando e o resultado das combinações é exibido 
direto na tela ou pode ser direcionado para um arquivo. Os parâmetros de 
entrada que serão combinados devem ser listados num arquivo com base 
numa sintaxe específica do PICT. Além dos parâmetros de entrada, essa 
sintaxe suporta grupo de parâmetros, restrições incondicionais e condicionais 
(IF-THEN-ELSE), como pode ser visto no exemplo abaixo de um arquivo com 
algumas combinações de navegadores e OS (sistema operacional) e uma 
restrição: 
 
Navegador: IE7, IE6, IE5 
OS: WINVISTA, WINXP 
IF [OS] = "WINVISTA" THEN [Navegador] = "IE7"; 
 
Na listagem abaixo, você poderá visualizar o resultado das combinações 
pairwise após a execução do PICT utilizando o arquivo citado no parágrafo 
anterior: 
 
Navegador OS 
IE6 WINXP 
IE7 WINVISTA 
IE7 WINXP 
IE5 WINXP 
 
Caso o Microsoft PICT não atenda as suas necessidades, vale a pena conferir 
o utilitário ALLPAIRS Test Case Generation62 que oferece funcionalidades 
semelhantes. Em tempo, no site pairwise.org63 você encontrará uma listagem 
de outras ferramentas interessantes para a geração de combinações duplas.61http://download.microsoft.com/download/f/5/5/f55484df-8494-48fa-8dbd-
8c6f76cc014b/pict33.msi 
 
62 http://www.satisfice.com/tools/pairs.zip 
63 http://www.pairwise.org/tools.asp 
 
161
Burp Suite 
 
O Burp Suite64 é um utilitário Open Source escrito em Java cuja principal 
função é monitorar e interagir com as requisições HTTP enviadas de um 
navegador para um servidor WEB e vice-versa. O Burp Suite se comporta 
com um Proxy, ou seja, um elemento capaz de monitorar, inspecionar e 
modificar todo o tráfego de informações entre o navegador e o servidor WEB. 
Por meio do Burp Suite, você poderá interceptar e validar o conteúdo das 
requisições HTTP (GET/POST), assim como, modificar os conteúdo das 
requisições para simular um hacker explorando uma vulnerabilidade da 
aplicação, Além disso, você poderá testar a robustez da aplicação quando 
dados incorretos são enviados ao servidor. O Burp Suite oferece uma opção 
de filtragem para exibir somente o tipo de requisição que importa no 
momento do teste, assim como, um mecanismo para visualizar o conteúdo da 
requisição renderizada em HTML para simular o que o navegador irá exibir, 
como pode ser visto na Figura 143. 
 
 
Figura 143: Burp Suite 
 
 
Caso o Burp Suite não atenda as suas necessidades, vale a pena conferir o 
utilitário TCPMon65 que oferece funcionalidades semelhantes. 
 
 
 
 
64 http://portswigger.net/proxy/download.html 
65 https://tcpmon.dev.java.net/ 
 
162
Camstudio 
 
O Camstudio66 é um utilitário Open Source para Windows cuja principal 
função é capturar toda a atividade exibida no seu monitor (abrir janelas, 
mover o mouse, digitar, etc) e converter para um vídeo no formato AVI ou 
Flash (SWF). Estes vídeos podem ser capturados para demonstrações, 
treinamentos, entre outras funções. No entanto, sob o ponto de vista de 
testes de software, você poderá gravar um vídeo a fim de fornecer uma 
evidência ao time de desenvolvimento de que existe um defeito em 
determinada funcionalidade da aplicação e os passos para reproduzi-lo. 
Durante o processo de gravação você poderá escolher se deseja gravar 
determinada região do monitor ou o monitor todo. Para dar ênfase ou 
destacar determinada ação ou região da tela, você poderá gravar a sua voz 
ou escolher alguns dos indicadores (setas, formas, balões, etc), fornecidos 
pelo CamStudio, como pode ser observado no exemplo apresentado na 
Figura 144. 
 
 
Figura 144: CamStudio 
 
Caso o CamStudio não atenda as suas necessidades, vale a pena conferir o 
utilitário Wink67 que oferece funcionalidades semelhantes. 
 
66 http://sourceforge.net/projects/camstudio/ 
67 http://www.debugmode.com/wink/ 
 
163
MWSnap 
 
O MWSnap68 é um utilitário gratuito para Windows cuja principal função é 
capturar uma imagem (screenshot) do seu monitor. Estas imagens podem ser 
capturadas para demonstrações, treinamentos, entre outras funções. Assim 
como o CamStudio, a imagem capturada poderá fornecer uma evidência ao 
time de desenvolvimento de que existe um defeito em determinada 
funcionalidade da aplicação. O MWSnap é muito superior em relação ao velho 
botão PrintScreen para capturar uma imagem (screenshot) do seu monitor. 
Entre outros recursos, você poderá capturar janelas, diálogos e até 
componentes específicos de uma janela (botões, grids, menus, etc). 
Adicionalmente, você poderá configurar o MWSnap para capturar uma região 
específica do seu monitor, como pode ser observado na Figura 145. 
 
 
Figura 145: MWSnap 
 
Caso o MWSnap não atenda as suas necessidades, vale a pena conferir o 
utilitário Screen Grab Pro69 que oferece funcionalidades semelhantes. 
 
68 http://www.mirekw.com/winfreeware/mwsnap.html 
69 http://www.traction-software.co.uk/downloads/ScreenGrabPro.zip 
 
164
WinMerge 
 
O WinMerge70 é um utilitário Open Source para Windows cuja principal 
função é realçar a diferença entre dois arquivos. O WinMerge é de grande 
utilidade quando é necessário durante a execução de um teste comparar um 
arquivo de saída (output) gerado pela aplicação em teste contra o mesmo 
arquivo gerado por uma versão anterior da mesma aplicação, por um outro 
build da mesma aplicação ou, até mesmo, pelo sistema legado. O WinMerge 
oferece um interface fácil de usar e bastante intuitiva. Além de realçar as 
diferenças entre dois arquivos, você poderá realizar operações de 
mesclagem/sincronização (merge) entre as diferenças dos arquivos a fim de 
tornar os arquivos idênticos ou fazer um arquivo receber as diferenças do 
outro, como pode ser visto na Figura 146. Entre os diversos recursos do 
WinMerge, devemos destacar o recurso de comparação de pastas, onde é 
realçada as diferenças entre os arquivos de duas pastas, as diferenças dos 
seus nomes, data de atualização, entre outros. 
 
 
Figura 146: WinMerge 
 
Caso o WinMerge não atenda as suas necessidades, vale a pena conferir o 
utilitário Perforce Visual Merge Tool71 que oferece funcionalidades 
semelhantes. 
 
70 http://winmerge.sourceforge.net/ 
71 http://www.perforce.com/perforce/products/merge.html 
 
165
Data Generator 
 
O Data Generator72 é uma aplicação WEB Open Source baseada em 
JavaScript, PHP and MySQL cuja principal função é gerar enormes volumes 
de dados para popular banco de dados de testes. Este tipo de utilitário tem 
grande serventia quando a aplicação é nova e não existem dados nas tabelas 
do banco de dados para realizar os testes. O Data Generator vem com uma 
série de templates com diversos tipos de dados para auxiliar a criação da 
massa de dados conforme a sua necessidade. No entanto, muitos templates 
correspondem a dados específicos de outros países (Canadá, Estados Unidos, 
etc). Por outro lado, por ser uma ferramenta Open Source, você poderá fazer 
o download do código fonte e realizar as modificações necessárias para 
atender as suas necessidades (geração de CPF, telefones no formato 
brasileiro, CEP no formato brasileiro e assim por diante), como pode ser visto 
na Figura 147. 
 
 
 
Figura 147: Data Generator 
 
 
 
 
 
 
72 http://www.generatedata.com/ 
 
166
Firebug 
 
O Firebug73 é um utilitário Open Source cuja principal função é editar, 
depurar e monitorar o conteúdo HTML, CSS e JavaScript utilizados em 
aplicações WEB. O Firebug é uma extensão (add-on) do navegador Firefox. 
Por meio do Firebug, você poderá monitorar o que está acontecendo por 
detrás dos panos da aplicação em teste (on-the-fly enquanto você navega 
pelas páginas). Entre os diversos recursos oferecidos pelo Firebug, podemos 
destacar a visualização do conteúdo de cada requisição entre navegador e o 
servidor e a possibilidade de monitorar as requisições XML utilizadas em 
páginas AJAX. Além disso, você poderá monitorar e depurar o código 
JavaScript enquanto ele é executado e analisar a performance do 
download/execução de cada elemento da página da aplicação WEB, como 
pode ser visto na Figura 148. 
 
 
Figura 148: Firebug 
 
 
 
 
73 http://getfirebug.com/ 
 
167
Considerações Finais 
 
Ferramentas similares não apresentadas neste 
livro 
 
Quando este livro ainda era uma idéia embrionária, entre riscos e rabiscos 
numa folha em branco criei um MindMap74 definindo as ferramentas que 
fariam parte do seu escopo. Após uma pequena pesquisa, cheguei a 
conclusão de que o escopo deveria ser reduzido a fim de evitar que o livro 
levasse muito tempo para ser escrito e ficasse muito desatualizado (as 
ferramentas Open Source evoluem numa velocidade fantástica). 
 
O escopo foi redefinido tendo em mente asferramentas realmente 
essenciais; outro ponto que pesou muito foi o tamanho das comunidades 
apoiando e suportando estas ferramentas. Ferramentas com grandes 
comunidades e liberações freqüentes foram privilegiadas em relação às 
outras. 
 
De qualquer forma, mantive a listagem original a fim de apresentar as 
ferramentas similares que não foram abordadas neste livro (talvez sejam 
adicionadas novas ferramentas na próxima edição de acordo com o retorno 
do leitor). Caso as ferramentas apresentadas neste livro não atendam as suas 
necessidades, sinta-se à vontade para procurar um similar equivalente entre 
as ferramentas apresentadas na Tabela 4. 
 
Categoria Ferramenta 
GanttProject http://ganttproject.biz/ 
ProjectKoach http://www.projectkoach.com/ 
]project-open[ http://www.project-open.com/ 
OpenWorkbench http://www.openworkbench.org/ 
XPlanner http://www.xplanner.org/ 
WebCollab http://webcollab.sourceforge.net/ 
OpenProj http://openproj.org/ 
Gestão de 
projetos 
Mindquarry http://www.mindquarry.com/ 
OpenSTA http://www.opensta.org/ 
WEBLOAD http://www.WEBload.org/ 
Teste de 
performance 
The Grinder http://grinder.sourceforge.net/ 
rth http://www.rth-is-quality.com Gestão de 
testes TestMaster http://testmaster.sourceforge.net/ 
 
74 http://en.wikipedia.org/wiki/Mind_Mapping 
 
168
Testitool http://majordojo.com/testitool/ 
QaManager http://qamanager.sourceforge.net/ 
Test Case Web (TCW) 
http://tcw.sourceforge.net/ 
Testopia http://www.mozilla.org/projects/testopia/ 
Bugzilla http://www.bugzilla.org/ 
Scarab http://scarab.tigris.org/ 
BugNET http://www.bugnetproject.com/ 
Gestão de 
defeitos 
TRAC http://trac.edgewall.org/ 
OSRMT http://www.osrmt.com/ 
Tiger PRO 
http://www.seecforum.unisa.edu.au/SEECTools.html 
Xuse http://xuse.sourceforge.net/ 
TRUC http://sourceforge.net/projects/truc 
REM (REquisite Management) 
http://www.lsi.us.es/descargas/descarga_programas.php?id=
3 
Plandora http://plandora.sourceforge.net/ 
Gestão de 
requisitos 
Jeremia http://jeremia.sourceforge.net/ 
Watir (WEB) http://wtr.rubyforge.org/ 
Canoo WEBTest (WEB) http://WEBtest.canoo.com/ 
actiWATE (WEB) 
http://www.actiwate.com/ 
Apodora (WEB) http://www.apodora.org/ 
Abbot (Java Swing) http://abbot.sourceforge.net 
SoapUI (WEBServices) http://www.soapui.org/ 
SOAPSonar Personal Edition (WEBServices) 
http://www.crosschecknet.com/ 
LISA WS-Testing (WEBServices) 
http://www.itko.com/site/products/lisa/ws_testing.jsp 
Squish for KDE (Linux) http://www.froglogic.com 
GNU/Linux Desktop Testing Project (Linux) 
http://ldtp.freedesktop.org/wiki/Home 
SharpRobo (WinForm .NET) 
http://confluence.public.thoughtworks.org/display/SHRO/Ho
me 
Testes 
funcionais 
FitNesse http://fitnesse.org/ 
Estimativas Construx Estimate 
http://www.construx.com/Page.aspx?nid=68 
WinCVS 
http://www.wincvs.org/ 
Controle de 
versões 
Subversion 
http://subversion.tigris.org/ 
 
 
169
 darcs 
http://darcs.net/ 
Tabela 4: Ferramentas similares não apresentadas neste livro 
 
Para os leitores que ficaram interessados no MindMap com as ferramentas do 
escopo original deste livro, os rabiscos originais foram convertidos num 
formato mais amigável, como pode ser visto na Figura 149. Este MindMap 
será atualizado constantemente para acompanhar a evolução das 
ferramentas de testes Open Source e será disponibilizado para a comunidade 
brasileira de testes gratuitamente no seguinte endereço: 
 
http://www.mindomo.com/view?m=d1535d37f8b0aa6df765a1db90bfa317 
 
 
170
 
Figura 149: Ferramentas similares não apresentadas neste livro 
 
 
 
 
 
171
Repositórios de ferramentas Open Source 
 
Por mais abrangente que sejam as categorias e ferramentas apresentadas 
neste livro, seria ingênuo pensar que ele ofereceria soluções que atendessem 
a necessidade de todos os leitores, afinal, muitos de vocês devem precisar de 
soluções específicas para a realização de testes de diversos tipos e nas mais 
diversas plataformas. 
 
Pensando neste cenário, fiz uma pesquisa extensa a fim de trazer para o 
leitor uma lista detalhada com os maiores e melhores repositórios de 
ferramentas Open Source do mundo. 
 
Assim, você poderá pesquisar a solução que se enquadre na sua necessidade 
no momento que você quiser, como pode ser visto na Tabela 5. 
 
Categoria Sites 
Categoria ‘Testing’ do site SourceForge, um dos maiores 
repositórios de software Open Source do mundo. 
http://sourceforge.net/softwaremap/trove_list.php?form_cat=5
75 
Categoria ‘Quality Assurance’ do site SourceForge, um dos 
maiores repositórios de software Open Source do mundo. 
http://sourceforge.net/softwaremap/trove_list.php?form_cat=5
65 
Site especializado em ferramentas para teste de software. 
Neste site as ferramentas são organizadas e classificadas em 
diversas categorias tais como: testes de performance, gestão 
de defeitos, testes funcionais e assim por diante. 
http://www.opensourcetesting.org/ 
Site especializado em teste e qualidade de software. Neste site 
existe uma seção listando diversas ferramentas agrupadas por 
diversas categorias. 
http://www.softwareqatest.com/qatWEB1.html 
Categoria ‘Testing’ do site FreshMeat, um dos maiores 
repositórios de software Open Source do mundo. 
http://freshmeat.net/browse/836/ 
Categoria ‘Quality Assurance’ do site FreshMeat, um dos 
maiores repositórios de software Open Source do mundo. 
http://freshmeat.net/browse/822/ 
Diversas 
Categoria ‘Testing’ do site Tigris, um repositório de software 
Open Source. 
http://testing.tigris.org/ 
 
172
 Site especializado em teste de software. Neste site existe uma 
seção listando diversas ferramentas agrupadas por diversas 
categorias. 
http://www.testingfaqs.org/ 
C# e .NET Site especializado em ferramentas Open Source escritas em c# 
para testes funcionais de aplicações WEB 
http://csharp-source.net/open-source/WEB-testing-tools 
Linux Site especializado em ferramentas Open Source para realizar 
testes do sistema operacional Linux. 
http://ltp.sourceforge.net/tooltable.php 
Site especializado em ferramentas Open Source escritas em 
Java para realizar testes diversos. 
http://www.java-source.net/open-source/testing-tools 
Site especializado em ferramentas Open Source escritas em 
Java para realizar testes diversos. 
http://javatoolbox.com/categories/tests 
Java 
Site especializado em ferramentas Open Source escritas em 
Java para realizar testes diversos. 
http://community.java.net/projects/ 
Tabela 5: Repositórios de ferramentas Open Source 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
173
Alternativas comerciais 
 
É impossível apresentar e discutir ferramentas Open Source sem pensar nas 
ferramentas comerciais similares e vice-versa. A título de comparação, serão 
apresentadas na Tabela 6 as principais ferramentas comerciais para cada 
categoria apresentada neste livro. 
 
Categoria Ferramenta 
TraceGP 
http://www.tracegp.com.br/ 
Microsoft Office Project 
http://office.microsoft.com/en-
us/project/FX100487771033.aspx 
Project Builder 
http://www.projectbuilder.com.br/ 
BaseCamp 
http://www.basecamphq.com/ 
Gestão de projetos 
ZOHO Projects 
http://projects.zoho.com/jsp/home.jsp 
Mercury LoadRunner 
http://www.mercury.com/us/products/performance-
center/loadrunner/ 
WebLOAD Professional 
http://www.radview.com/ 
Empirix e-Load 
http://www.empirix.com/products/testing/e-Load.asp 
Rational Performance Tester 
http://www-
306.ibm.com/software/awdtools/tester/performance/ 
Compuware QALoad 
http://www.compuware.com/solutions/qaload.htm 
Testesde 
performance 
Borland SilkPerformer 
http://www.borland.com/us/products/silk/silkperforme
r/index.html 
RSI/QA-Teste 
http://www.rsinet.com.br/modules/content/index.php?
id=9 
TestLog 
http://www.testlog.com/ 
Mercury Quality Center 
http://www.mercury.com/us/products/quality-center/ 
Gestão de testes 
TestTrack TCM 
http://www.seapine.com/tttcm.html 
 
174
Rational TestManager 
http://www-
306.ibm.com/software/awdtools/test/manager/ 
Compuware QA Director 
http://www.compuware.com/products/qacenter/qadire
ctor.htm 
SilkCentral Test Manager 
http://www.borland.com/us/products/silk/silkcentral_t
est/index.html 
FogBugz 
http://www.fogcreek.com/FogBugz/ 
Jira 
http://www.atlassian.com/software/jira/ 
yKAP 
http://www.ykap.com/ 
Gestão de defeitos 
Rational ClearQuest 
http://www-
306.ibm.com/software/awdtools/clearquest/ 
Rational RequisitePro 
http://www-306.ibm.com/software/awdtools/reqpro/ 
Borland Caliber 
http://www.borland.com/us/products/caliber/index.ht
ml 
Compuware Optimal Trace 
http://www.compuware.com/products/optimaltrace/ 
Gestão de 
Requisitos 
Telelogic DOORS Fastrak 
http://www.telelogic.com/Products/doors/doorsfastrak
/index.cfm 
Mercury QuickTest Professional 
http://www.mercury.com/us/products/quality-
center/functional-testing/quicktest-professional/ 
Rational Functional Tester 
http://www-
306.ibm.com/software/awdtools/tester/functional/ 
QA Wizard Pro 
http://www.seapine.com/qawizard.html 
Compuware QARun 
http://www.compuware.com/qarun.htm 
Testes funcionais 
TestComplete 
http://www.automatedqa.com/products/testcomplete/ 
Controle de versões Perforce 
http://www.perforce.com/ 
 
 
175
Microsoft Visual Source Safe 
http://msdn2.microsoft.com/en-
us/vstudio/aa718670.aspx 
Rational ClearCase 
http://www-
306.ibm.com/software/awdtools/clearcase/ 
SourceGear Vault 
http://www.sourcegear.com/vault/downloads.html 
 
Tabela 6: Comparação com ferramentas comerciais 
 
Outros autores/pesquisadores ao redor do mundo também disponibilizaram 
comparações entre as soluções comerciais e Open Source. Confira abaixo 
alguns exemplos selecionados especialmente para o leitor: 
 
Comparação entre ferramentas de gestão de projetos 
http://www.blogtoplist.com/software/blogdetails-11377.html 
http://www.openworkbench.org/index.php?option=com_content&task=view&
id=7&Itemid=15 
 
Comparação entre ferramentas de gestão de requisitos 
http://www.volere.co.uk/tools.htm 
 
Comparação entre ferramentas de controle de versões 
http://better-scm.berlios.de/comparison/comparison.html 
http://en.wikipedia.org/wiki/Comparison_of_revision_control_software 
ftp://ftp.software.ibm.com/software/rational/web/reports/forrester_scm_wav
e_2007.pdf 
 
Comparação entre ferramentas de gestão de defeitos 
http://en.wikipedia.org/wiki/Comparison_of_ticket-tracking_systems 
http://www.javaworld.com/javaworld/jw-03-2007/jw-03-bugs.html 
http://www.testingfaqs.org/t-track.html 
http://www.pronus.eng.br/artigos_tutoriais/analises/ferramentasControleMud
anca.php 
 
Comparação entre ferramentas de automação de testes funcionais 
http://www.vcaa.com/tools/Ray%20Robinson.pdf 
http://venus.cs.depaul.edu/se682/FinalPapers/PRV.doc 
www.forrester.com/Events/Content/0,5180,-1403,00.ppt 
http://en.wikipedia.org/wiki/List_of_GUI_testing_tools 
 
Comparação entre ferramentas de teste de performance 
http://bugs.sakaiproject.org/confluence/download/attachments/7105/HTTP_T
est_Tool_Comparison.xls?version=1 
 
176
Comparação entre ferramentas para virtualização de sistemas 
operacionais 
http://en.wikipedia.org/wiki/Comparison_of_virtual_machines 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
177
Referências sobre teste de software 
 
Conforme mencionamos anteriormente, não faz parte do escopo deste livro 
apresentar a teoria ou técnicas de teste de software. O livro se propõe a 
apresentar as ferramentas essenciais para a gestão, automação e apoio das 
atividades de teste de software. No entanto, se o leitor tiver interesse em 
aprofundar os seus conhecimentos nessa fascinante área da engenharia de 
software, segue abaixo a listagem dos livros nacionais sobre teste de 
software mais importantes da atualidade: 
 
ƒ INTHURN, Cândida. Qualidade e teste de software. 1ª edição, 
Florianópolis: Visual Books, 2001. 
ƒ KOSCIANSKI, A. Soares, M. S. Qualidade de Software. Editora 
Novatec, Segunda Edição, 2007. 
ƒ BARTIE Alexandre, Garantia da Qualidade de Software, São Paulo: 
Elsevier Editora Ltda, 2002. 
ƒ MECENAS, IVAN et al. Qualidade em Software. Editora Alta Books, 
2005. 
ƒ RIOS, Emerson et al. Teste de Software. Editora Alta Books, 2003. 
ƒ RIOS, Emerson. Análise de riscos em projetos de teste de software. 
Editora Alta Books, 2005. 
ƒ RIOS, Emerson et al. Projeto e Engenharia de Software: Teste de 
Software. Editora Alta Books, Segunda Edição, 2006. 
ƒ MALDONADO, José Carlos et al. Introdução ao Teste de Software. 
Editora Campus, 2007. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
178
Sobre o autor 
 
 
Cristiano Caetano (c_caetano@hotmail.com) 
 
 
É certificado CBTS pela ALATS. Com mais de 
10 anos de experiência, já trabalhou na área 
de qualidade e teste de software para 
grandes empresas como Zero G, DELL e HP 
Invent. 
 
É colunista na área de Teste e Qualidade de 
software do site linhadecodigo.com.br e autor 
do livro CVS: Controle de Versões e 
Desenvolvimento Colaborativo de Software. 
 
O autor também pode ser contactado no seguinte endereço: 
http://spaces.msn.com/softwarequality/ 
http://www.testexpert.com.br/ 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
179
 
Bibliografia Recomendada 
 
 
Teste de Software 
ƒ INTHURN, Cândida. Qualidade & teste de software. 1ª edição, 
Florianópolis: Visual Books, 2001. 
ƒ MOLINARI, Leonardo. Testes de Software: Produzindo Sistemas 
Melhores e Mais Confiáveis, São Paulo: Érica, 2003. 
ƒ KOSCIANSKI, A. Soares, M. S. Qualidade de Software. Editora 
Novatec, Segunda Edição, 2007. 
ƒ BARTIE Alexandre, Garantia da Qualidade de Software, São Paulo: 
Elsevier Editora Ltda, 2002. 
ƒ MECENAS, IVAN et al. Qualidade em Software. Editora Alta Books, 
2005. 
ƒ RIOS, Emerson et al. Teste de Software. Editora Alta Books, 2003. 
ƒ RIOS, Emerson. Análise de riscos em projetos de teste de software. 
Editora Alta Books, 2005. 
ƒ RIOS, Emerson et al. Projeto e Engenharia de Software: Teste de 
Software. Editora Alta Books, Segunda Edição, 2006. 
 
Gestão de Defeitos e Testes 
ƒ FUTRELL, Robert T. Quality Software Project Management. Prentice 
Hall PTR, 2004. 
ƒ BLACK, Rex. Critical Testing Processes: Plan, Prepare, Perform, 
Perfect. Addison Wesley, 2003 
ƒ CRAIG Rick D. Systematic Software Testing. Artech House, 2002. 
 
Gestão de Projetos 
ƒ MCCONNELL, Steve. Software Project Survival Guide: how to be sure 
your first important project isn't your last / Steve McConnell. Microsoft 
Press, 2002. 
ƒ THOMSETT, Rob. Radical Project Management. Prentice Hall PTR, 
2002. 
ƒ CHIN, Gary. Agile Project Management: How to Succeed in the Face of 
Changing Project Requirements. AMACOM, 2004 
 
Automação de Testes Funcionais e de Aceitação 
ƒ FEWSTER, Mark et al. Software Test Automation: Effective use of test 
execution tools. Addison-Wesley, 1999. 
ƒ MOSLEY, Daniel J. et al. Just Enough Software Test Automation. 
Prentice Hall, 2002. 
 
180
ƒ DUSTIN, Elfriede, et al. Automated Software Testing: Introduction, 
Management. Addison-Wesley, 1999. 
 
Automação de Testesde Performance 
ƒ MENASCE Daniel A., et al. Performance by Design: Computer Capacity 
Planning by Example. Prentice Hall PTR, 2004. 
ƒ SUBRAYA, B. M. Integrated Approach to Web Performance Testing: A 
Practitioner's Guide. IRM Press, 2006. 
ƒ Microsoft ACE Team. Performance Testing Microsoft .NET Web 
Applications. Microsoft Press, 2002. 
 
Controle de Versões e Gerência de Configuração de Software 
ƒ CAETANO, Cristiano. CVS - Controle de Versões e Desenvolvimento 
Colaborativo de Software (Concurrent Versions System). Editora 
Novatec, 2004. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
181
Bibliografia 
 
ƒ PRESSMAN, Roger. Engenharia de Software. São Paulo: Makron 
Books, 1995. 
ƒ MYERS, Glenford. The Art of Software Testing. New York: Wiley, 
1979. 
ƒ INTHURN, Cândida. Qualidade e Teste de Software, Visual Books, 
2001. 
ƒ MOLINARI, Leonardo. Testes de Software: Produzindo Sistemas 
Melhores e Mais Confiáveis, São Paulo: Érica, 2003. 
ƒ BARTIE Alexandre, Garantia da Qualidade de Software, São Paulo: 
Elsevier Editora Ltda, 2002. 
ƒ RIOS, Emerson et al. Teste de Software. Editora Alta Books, 2003. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
182
Índice Remissivo 
 
&nbsp ..................................... 72 
Accessors ................................ 73 
acessos simultâneos ................143 
Actions .................................... 73 
AJAX ....................................... 78 
ALLPAIRS ...............................162 
ANT .......................................124 
Apache Tomcat ............... 111, 127 
Área de trabalho .....................145 
Assertions...........................73, 89 
AUT ........................................ 71 
automação de testes ................ 68 
AVI ........................................164 
Bandwidth ..............................139 
BareTail..................................158 
bookmarks compartilhados........ 62 
Branch ...................................146 
Browser Recorder....................134 
bug ......................................... 16 
bug tracking system ................. 15 
Build ....................................... 46 
Burp Suite ..............................163 
calendário................................ 57 
campos personalizados ............. 27 
Camstudio ..............................164 
Categorias ............................... 35 
Change Log ............................. 26 
Checkout ................................145 
Class Path................................ 85 
clickAndWait ............................ 78 
cliente ..................................... 51 
cobertura dos testes ................. 68 
combinação dupla ...................162 
Commit ..................................145 
componente............................. 35 
Concurrent Connections...........139 
Conditional Goto .....................107 
Control Panel ........................... 71 
controle de versões .................143 
Cooldown ...............................139 
cross-site scripting.................... 77 
Custom Component Resolver .....89 
CVS ....................................... 144 
Data Generator....................... 167 
Delay ..................................... 121 
depurar..........76, 84, 86, 102, 168 
DHTML ....................................69 
Diff ........................................ 146 
divulgação de notícias ...............25 
Duration Assertion .................. 119 
e-book .....................................12 
endpoints.................................96 
Especificação de Requisito .........32 
Especificação de Teste ..............35 
estresse ................................. 111 
fases........................................51 
ferramentas comerciais similares
.......................................... 174 
Ferramentas de apoio ............. 157 
Finalização ...............................94 
Firebug .................................. 168 
Firefox . 69, 71, 74, 75, 76, 77, 168 
Fixture .....................................94 
Fixtures....................................86 
Flash...................................... 164 
FTP........................................ 111 
Gerência de Configuração........ 143 
gerenciamento de requisitos ......31 
gestão de defeitos ....................15 
gestão de projetos ....................50 
gestão de testes .......................28 
GET ....................................... 115 
Groovy Script.......................... 107 
HeavyLoad ............................. 159 
HTTP Authorization Manager.... 127 
HTTP Proxy Server.................. 115 
HTTP Response Code .............. 125 
Importação ............................ 148 
Inicialização..............................94 
instância do navegador .............79 
Internet Explorer ....... 69, 134, 135 
Java Script ...............................69 
 
183
JMeter....................................111 
JUnit ....................................... 93 
Jython..................................... 84 
keyword .................................. 40 
Liberação................................145 
lista de discussão ..................... 58 
Listeners.................................122 
Loop Count.............................114 
Main Class ............................... 85 
MakeLogicTail .........................158 
Mantis ..................................... 16 
Marathon................................. 84 
Marathon Control Center........... 91 
matriz de rastreabilidade........... 29 
menus de contexto.....75, 147, 153 
métricas .................................. 48 
Microsoft ................................132 
Milestones ............................... 46 
MindMap ................................169 
modo interativo........................ 80 
Module ...................................146 
Modules................................... 86 
módulos reutilizáveis ...........88, 91 
Módulos reutilizáveis................. 84 
MWSnap.................................165 
níveis de prioridade .................. 45 
Open Source2, 5, 6, 7, 10, 12, 13, 
14, 16, 29, 51, 68, 69, 84, 96, 
110, 111, 127, 144, 147, 158, 
163, 164, 166, 167, 168, 169, 
171, 172, 173, 174, 176 
Page Groups ...........................140 
pairwise..................................162 
palavra-chave .......................... 40 
pausar................................76, 88 
Perforce Visual Merge Tool.......166 
performance ...........................111 
php-Collab ............................... 51 
PICT ......................................162 
plataforma WEB ......................110 
PMBOK.................................... 50 
pós-processadores...................111 
POST......................................115 
pré-processadores...................111 
PrintScreen............................. 165 
prioridade ................................16 
Process Explorer ..................... 160 
processo de teste......................28 
project management system......50 
projeto.....................................50 
Property Transfer.................... 107 
Python .....................................84 
qualidade .................................13 
Ramo..................................... 146 
Ramp-Up................................ 114 
Record ......... 88, 91, 133, 134, 139 
registro de bugs .......................20 
relatórios..................................48 
Release.................................. 145 
Remote Control ........................79 
repositório.............................. 144 
repositórios de ferramentas Open 
Source................................ 172 
Request Editor..........................99 
requisições de suporte...............66 
requisições HTTP ....................111 
requisitos .................................32 
Response Assertion................. 118 
resultado da execução...............47 
Revisão.................................. 144 
ROI .........................................14 
Ruby........................................81 
Scheduler............................... 114 
Schema Compliance ................ 103 
Screen Grab Pro ..................... 165 
Selenês ....................................71 
Selenese ..................................71 
Selenium..................................69 
Selenium Core ..........................70 
Selenium IDE ...........................74 
Selenium RC.............................79 
Selenium Server........................79 
Setup.......................................94 
severidade ...............................16 
Simple Contains ...................... 103 
Simple NotContains................. 104 
Simple Object Access Protocol....96 
site do projeto ..........................64 
 
184
Slow Play................................. 93 
snapshot ................................161 
SOAP ...................................... 96 
SOAP Fault .............................104 
SoapUI.................................... 96 
SSL/HTTPS .............................117 
sumário dos bugs..................... 24 
Swing...................................... 84 
syntax highlight........................ 96 
SysInternals............................160 
tabelas HTML........................... 69 
Tail for Win32 .........................158 
tarefas .................................... 54 
TCO ........................................ 14 
TCPMon..................................163 
Teardown ................................ 94 
tempo estimado ....................... 56 
Test Cases............................... 39 
test management system.......... 28 
Test Step................................101 
Test Suite Runner ...................101 
Test Suites .........................29, 42 
teste de software ....................178 
testes de performance .............110 
testes de regressão .................. 68 
testFrame................................ 72 
TestLink .................................. 29 
TestRunner.............................. 70 
Thread Group .........................113 
time do projeto ........................ 51 
Timer..................................... 121 
TortoiseCVS............................ 147 
TrafficEmulator....................... 159 
Violet .......................................87 
virtualização ........................... 161 
virtualizado............................. 161 
VirtualPC................................ 161 
VMWARE................................ 161 
volume................................... 111 
Warmup................................. 139 
WAS ...................................... 132 
WEB Application Stress............ 132 
WEB Service Description Language
............................................96 
WEB Services ...........................96 
Websites ..................................54 
Wink...................................... 164 
WinMerge .............................. 166 
worflow....................................16 
WorkBench............................. 115 
Workspace ............................. 145 
Wrapper API.............................79 
WSDL ......................................96 
XAMMP .........................17, 30, 52 
XML.........................................96 
XmlHttpRequest........................80 
XPATH .....................................96 
XPath Match ........................... 104 
XSS .........................................77 
 
 
185