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........................................... 171 Alternativas comerciais ...................................................................... 173 Referências sobre teste de software ................................................... 177 Sobre o autor ................................................................................... 178

Bibliografia Recomendada ..................................................................... 179 Bibliografia .......................................................................................... 181 Índice Remissivo .................................................................................. 182

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 the job, 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 v1.0

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 mecanismo de 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://shop.linhadecodigo.com.br/

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 e senha. 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á garantir o 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 “Print Test 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

47

Figura 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: Test Suite: 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ífico deste 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 o interpretador 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ém um 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=e2c0585a-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á configurar o 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á selecionar o 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 possibilidade de 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 pode ser 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 realizados utilizando 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 for Win3252 é 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 as ferramentas 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/ ]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 TestMaster http://testmaster.sourceforge.net/

Gestão de testes

Testitool http://majordojo.com/testitool/

74 http://en.wikipedia.org/wiki/Mind_Mapping

168

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 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/ 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

Testes funcionais

FitNesse http://fitnesse.org/ Estimativas Construx Estimate

http://www.construx.com/Page.aspx?nid=68 WinCVS http://www.wincvs.org/ Subversion http://subversion.tigris.org/

Controle de versões

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

169

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

Figura 149: Ferramentas similares não apresentadas neste livro

170

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=575 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=565 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/

171

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

172

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

Testes de performance

Borland SilkPerformer http://www.borland.com/us/products/silk/silkperformer/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

173

Rational TestManager http://www-306.ibm.com/software/awdtools/test/manager/ Compuware QA Director http://www.compuware.com/products/qacenter/qadirector.htm SilkCentral Test Manager http://www.borland.com/us/products/silk/silkcentral_test/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.html 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/

174

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_wave_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/ferramentasControleMudanca.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_Test_Tool_Comparison.xls?version=1

175

Comparação entre ferramentas para virtualização de sistemas operacionais http://en.wikipedia.org/wiki/Comparison_of_virtual_machines

176

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. 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. MALDONADO, José Carlos et al. Introdução ao Teste de Software.

Editora Campus, 2007.

177

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/

178

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. DUSTIN, Elfriede, et al. Automated Software Testing: Introduction,

Management. Addison-Wesley, 1999.

179

Automação de Testes de 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.

MOLINARI, Leonardo. Gerência de Configuração - Técnicas e Práticas no Desenvolvimento do Software. Editora Visual Books, 2007.

180

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.

181

Í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

182

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

183

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

184