O documento discute duas ferramentas de automação de teste: Watir e Canoo WebTest. O Watir é um framework para teste de aplicações web em Ruby, enquanto o Canoo WebTest permite testes automatizados de aplicações web usando arquivos XML ou código Groovy. Ambas as ferramentas simulam interações com páginas web para validar funcionalidades.

1. Teste de Software
Ferramentas de automação de teste
Manaus, 2013
1

2. Marcos Felipe Paes Pessoa
20902016
◦Watir – Web Application Testing in Ruby
◦Canoo – Web Test
Manaus, 2013
2

3. Menu
Watir - Web Application Testing in Ruby ...................................................................................................... 4
O que é o Watir? ................................................................................................................................... 4
Por que usar o Watir? ........................................................................................................................... 4
Comandos de Iniciação ......................................................................................................................... 5
Acessando campos ................................................................................................................................ 5
Verificando conteúdos na página ......................................................................................................... 6
Assertions .............................................................................................................................................. 6
Principais componentes, seus atributos e suas ações. ........................................................................... 7
Canoo WebTest........................................................................................................................................... 10
Porque Canoo WebTest?..................................................................................................................... 11
Instalando o Canoo WebTest .............................................................................................................. 11
Criando um projeto de teste Canoo ..................................................................................................... 12
Dê um nome para o seu projeto Canoo. .............................................................................................. 12
Execução dos casos de teste Canoo .................................................................................................... 13
Referências.................................................................................................................................................. 14
3

4. Watir - Web Application Testing in Ruby
O que é o Watir?
Web Application Testing in Ruby ou simplesmente WATIR, é um framework criado com o
objetivo de permitir a automação de testes em aplicações e páginas Web. Sua abordagem é feita
diretamente com a manipulação do browser, simulando uma navegação do usuário pela
página. Até pouco tempo, Watir trabalhava somente com Internet Explorer (IE) 5.5, 6 e 7
utilizado em Windows 2000, XP, 2003 Server e Vista, porém as últimas versões trazem suporte a
Firefox para Windows, Linux e Mac, possibilitando a validação de uma aplicação em diversos
ambientes
O Watir é uma ferramenta para você testar aplicações Web, sob a licença BSD. Ela é um
conjunto de bibliotecas em Ruby que permite você automatizar os seus testes. Você escreve os
seus testes em Ruby e pode rodá-los no IE, Firefox, Chrome, Safari e Opera.
Watir é implementada e mantida por Bret Pettichord, Paul Rogers, Jonathan Kohl, Angrez
Singh, Charley Baker e Zeljko Filipin. Watir éopensource e com seus comandos e funções
particulares permite então que possamos controlar os objetos HTML e JavaScript presentes na
aplicação Web, simulando os cliques em links, botões e os demais campos. Watir tem sido usado
para testes de sistemas, testes funcionais e teste de aceitação do usuário.
Como seu próprio nome diz (Web Application Testing in Ruby), Watir é baseada na linguagem
de programação Ruby, que tem se destacado como uma forte ferramenta para desenvolvimento
Web apoiado por um framework chamado Rails. Framework este que vem ganhando adeptos
principalmente em projetos que utilizam metodologias “ágeis” como o Xp e o Scrum, inclusive
no mercado brasileiro. Em minhas referências estão alguns sites interessantes para quem queira
conhecer mais sobre Rails.Apresentarei de forma resumida a linguagem Ruby, pois torna-se
necessário o conhecimento básico da linguagem para se aproveitar melhor os recursos do Watir.
Por que usar o Watir?
Os motivos para usar o Watir são:
É uma ferramenta open source e não há custos para usar;
A comunidade do Watir está crescendo e é muita ativa;
Ele usa Ruby, uma linguagem de script moderna e completa e que possui uma baixa
curva de aprendizado (em comparação com Java, por exemplo);
Ele suporta qualquer aplicação web, não importando a linguagem na qual ela foi
desenvolvida;
O Watir suporta múltiplos browsers e diferentes plataformas;
4

5. Pré-requisitos e instalação:Para o uso do Watir torna-se necessário a instalação do interpretador
Ruby e do pacote que contém o Watir. A instalação do Ruby já inclui um editor de código
chamado SciTE que utilizaremos no exemplo, o netbeans também possui suporte ao Ruby.
Watir não utiliza da técnica conhecida como Record/Playback, onde o arquiteto de testes grava o
script através do movimento do mouse e teclado. Os scripts são escritos mesmo “na unha”,
portanto o recomendado é que o responsável pelo uso do Watir tenha algum conhecimento de
lógica de programação e dos atributos das tags HTML.
Esse conhecimento em desenvolvimento se torna importante, visto que estamos falando de
programação de scripts e para que possamos ter um produto final de qualidade, podem ser
aplicados todos os conceitos e boas práticas de programação.
Comandos de Iniciação
require 'watir'
Carrega a biblioteca do Watir
ie =
Watir::IE.start('http://localhost:8080')
Inicia o Internet Explorer (IE) usando a URL desejada.
ie.close
Fecha o IE.
ie = Watir::IE.attach(:title, 'title')
Necessário para que o Waitr reconheça uma janela do
IE que se abre a partir da janela principal e precisará ser
manipulada, por exemplo.
Acessando campos
ie.text_field(:name,
'name').set('value')
Permite se acessar um campo do tipo texto (text field) especificado
pelo atributo “name” da tag e atribui a ele um valor (value)
ie.button(:value,
'value').click
Clica em um botão especificado pela tag “value”
5

6. ie.button(:name,
'name').click
Clica em um botão especificado pela tag “name”
ie.checkbox(:name,
'name').set
Marca uma caixa de seleção (check box) especificada pela tag
"name"
ie.object(:attribute,
'name').flash
Pode ser usada com qualquer campo ou atributo. Este comando
destaca o objeto pretendido na cor amarela. Utilizada geralmente para
verificar se um determinado comando está encontrando o objeto na
tela.
Verificando conteúdos na página
ie.text.include?('text')
Retorna verdadeiro o falso se a página corrente contém o texto
especificado ou falso caso não encontre o texto. Pode ser usada
expressão regular.
ie.title
Retorna o título da página corrente
ie.html
Retorna todo o HTML do corpo da página.
ie.table(:id,
'recent_records).to_a
Retorna um array contendo todo o texto que está em uma
tabela.
ie.table(:id,
'recent_records')[2][1].text
Retorna o texto da primeira coluna da segunda linha de uma
tabela.
Assertions
assert_equal(expected, test_method) Compara o valor retornado com um valor esperado.
6

7. assert_match(regexp, test_method)
Compara o valor retornado com uma expressão regular.
assert(expression)
Verifica se uma expressão é verdadeira.
Principais componentes, seus atributos e suas ações.
1) Componente: text_field – Campo de texto:
Formas
de
localização
do
componente
na
tela:
text_field(como, conteudo)
verify_contains(“texto”) – verifica se texto está digitado no
campo e retorna verdadeiro ou falso
ie.text_field(:id,'user_name') # localiza o campo pelo ID
ie.text_field(:name,'address') # localiza o campo pelo
to_s – Retorna na tela os atributos do componente, nome,
ID, maxlength, tipo, etc.
NAME
ie.text_field(:index,2) # localiza o segundo campo na tela
dragContentsTo(como, conteúdo) – move o conteúdo do
campo para outro campo
Ações:
append(“texto”) – Adiciona texto no final do texto que já
set(“texto”) – Escreve texto no campo
está escrito no campo
clear – Limpa o conteúdo do campo
2) Componente: button – Botão:
Formas
de
localização
do
componente
na
tela:
button(como, conteudo)
ie.button(:caption, 'Login') # localiza o botão pelo que está
escrito no mesmo
ie.button(:id,'user_name') # localiza o botão pelo ID
ie. button(:name,'address') # localiza o botão pelo NAME
ie. button(:index,2) # localiza o segundo botão na tela
Ações:
click – clica no botão indicado
3) Componente: checkbox – Caixa de seleção:
Formas
de
localização
do
componente
na
tela:
ie.checkbox(:id,'user_name') # localiza o checkbox pelo ID
checkbox(como, conteudo, [value=nil])
7

8. ie.checkbox(:name,'address') # localiza o checkbox pelo
e o valor: sabado, muito usado pois alguns checkbox tem o
NAME
mesmo nome, porem valores diferentes
ie.checkbox(:index,2) # localiza o segundo checkbox na
tela
Ações:
ie.checkbox(:name,”dia”, “sabado”) # localiza o checkbox
que tem o nome: dia
set – seleciona o checkbox indicado
clear – remove a seleção do checkbox indicado
4) Componente: image – Imagens:
Formas de localização do componente na tela: image(como,
conteudo)
fileSize – retorna o tamanho da imagem
height – retorna a altura da imagem
ie.image(:src, “images/myPic.jpg”) # acessa pelo SRC
ie.image(:index,2) # acessa a segunda imagem da tela
width – retorna a largura da imagem
ie.image(:alt, "Clique aqui") # acessa pelo alt da imagem
save – Salva a imagem no seu computador, usar:
save(c:dirnomesomename.gif), se existir uma imagem
Ações:
com mesmo nome no diretório ele sobrescreve.
fileCreatedDate – retorna a data de criação da imagem
5) Componente: link :
Formas
de
localização
do
componente
na
tela:
checkbox(como, conteudo)
Ações:
click – clica no link
ie.link(:url, “login.asp”) #acessa pela url
link_string_creator – retorna em uma string os valores do
ie.link(:index,2) #acessa o segundo link da tela
link, pode ser acessado separadamente na variável através
ie.link(:title, "Picture") #acessa pelo título
de índices, isto é: variável[0], variável[1], etc
ie.link(:text, 'Click Me') #acessa pelo texto do link
link_has_image – verifica se uma imagem é usada como
parte do linkl, útil pois para clicar em imagem como link é
um comando diferente
6) Componente: SelectList – Lista de seleção, dropdownlist, listbox:
Formas
de
localização
do
componente
select_list(como, conteudo)
na
tela:
ie.select_list(:name, 'country') # acessa pelo nome
ie.select_list(:index, 2) #acessa o segundo select da tela
ie.select_list(:id, 'currency') # acessa pelo ID
8

9. Ações:
clearSelection – Limpa a seleção
includes?(texto) – verifica se texto está na lista e retorna
verdadeiro ou falso
select(item) – Seleciona item
getAllContents – retorna o conteúdo do select em um array,
– Verifica
retorna um array vazio caso não contenha dados no select,
selected?(item)
muito útil para verificar se foi carregado algum dado no
retorna verdadeiro ou falso
select
se item está
selecionado
e
set(item) – Faz o mesmo que o select(item)
getSelectedItems – Retorna o(s) itens selecionados em um
array.
7) Componente: Table – Tabela:
Formas de localização do componente na tela: table(como,
highlight(:set) – esse comando colore o fundo da tabela de
conteudo)
amarelo e fica em destaque na tela
ie.table(:id, 'currency') # acessa pelo ID
ie.table(:index, 2) #acessa a segunda tabela da tela
row_count – Retorna o número de linhas de uma tabela
row_values(X) – Retorna em um array os valores de uma
Ações:
[x] – Retorna/acessa a linha x da tabela
linha X
to_a – retorna o conteúdo da tabela em um arranjo de 2
column_count – retorna o número de colunas de uma tabela
dimensões
ou de uma linha da tabela, concatenanto com o
to_s – retorna todos os atributos do componente, name, id,
comando [x]
value, date, src, width, etc.
column_values(X) – retorna um arranjo com todos os
valores da coluna X
8) Ações gerais: todos – Algumas ações utilizadas em quase todos os componentes:
exist? – verifica se o componente existe e retorna
after_text – retorna o texto que existe antes do componente,
verdadeiro ou falso
útil para verificar o nome do campo em formulários por
exemplo
flash – faz o componente piscar na tela, útil para verificar
se o componente está sendo encontrado
before_text – retorna o texto que está após um determinado
componente
to_s – retorna todos os atributos do componente, name, id,
value, date, src, width, etc.
focus – coloca o foco no elemento
methods – retorna todos os métodos (ações) disponíveis
para um determinado componente
parent – retorna/acessa o componente pai
9

10. 9) Ações: Browser (Internet Explorer) – usado: ie.açao
IE.new – abre uma nova janela do Internet Explorer
goto(“endereço”) – direciona o Internet Explorer para um
text.include? “texto” – procura por texto na tela e retorna
verdadeiro ou falso
dado endereço
refresh – atualiza a pagina
attach(como, “conteudo”) – Retorna o endereço de uma
speed – Aumenta ou diminui a velocidade com que os
nova janela que se abriu para uma variável, para que se
objetos são acessados, inclusive a velocidade com que o
possa manipula-la, o como pode ser, :url ou :title.
texto é escrito na tela o uso é: ie.speed = :fast ou :slow
close – fecha uma janela específica do internet explorer
show_active – exibe o to_s do objeto que está com o foco
close_all – fecha todas as janelas abertas do Internet
show_divs – exibe os divs da tela
Explorer
show_forms
–
exibe
informações
sobre
todos
os
close_other – fecha uma janela que não seja a específicada
formulários da tela
bring_to_front – coloca a janela do Internet Explorer em
show_images – exibe informações sobre todas as imagens
primeiro plano
da tela
focus – coloca o foco em uma janela especificada do
show_links – exibe todos os links presentes na página
Internet Explorer
show_spans – exibe os spans da tela
front? – verifica se o Internet Explorer é a janela que esta
na frente da tela
maximize – Maximiza a janela
minimize – Minimiza a janela
restore – aciona para restaurar a janela
send_keys – envia comandos (CTRL + A, DEL, etc)
show_tables – exibe as tabelas da tela
status – retorna o texto que está na barra de status
title – retorna o título da janela
url – retorna a URL que a página está
visible= - esconde a janela do internet Explorer ou faz a
mesma aparecer após ser escondida, uso: ie.visible = true,
forward – aciona para avançar no Internet Explorer
ou false.
back – aciona para voltar no Internet Explorer
Visible – retorna a visibilidade atual da janela
Canoo WebTest
Canoo WebTest, que é uma ferramenta Open Source para testes automatizados de aplicações
web. O diferencial desta última ferramenta é que os testes podem ser feitos com arquivos XML
ou como códigos escritos na linguagem Groovy.
10

11. O Canoo permite o acionamento de funcionalidades do sistema baseado na web, simulando a
digitação de dados e o pressionamento/seleção de botões e elementos gráficos como combobox,
radio button, etc, simulando a utilização do sistema por um usuário qualquer, de forma
automática.
Além de acionar funcionalidades e fornecer dados para a aplicação, com o Canoo é possível
recuperar uma tela enviada pelo sistema e realizar a análise dessa página HTML, no sentido de
verificar o conteúdo de qualquer elemento gráfico ou até mesmo o aparecimento de alguma
mensagem específica, para que se chegue a conclusão sobre o sucesso ou falha do teste.
A MEDS descreve o momento e a forma de utilização dos testes de funcionalidade, além de
disponibilizar um guia de uso do Canoo.
Porque Canoo WebTest?
Ao buscar uma ferramenta para automação de testes, a seguinte lista de requisitos pode ser
referenciada:
Ser de baixo custo, de preferência gratuita.
Fácil de instalar e usar.
Facilmente "plugável" em scripts de build, de modo a permitir a execução automática dos
testes em servidores de integração contínua.
Os scripts devem ser escritos em uma linguagem de programação rica, que facilite o uso
de massas de dados externas e acesso ao banco de dados para preparação e validação dos
resultados dos testes.
Entre as ferramentas avaliadas, o Canoo WebTest atendeu a boa parte destes requisitos:
Custo de aquisição zero.
Relativamente simples quando comparada a outras ferramentas.
É executada a partir de uma task do ANT, que é a ferramenta de build padrão para
aplicações escritas em Java.
A linguagem padrão para os scripts é XML, que é muito limitada. Porém é possível criar
scripts em Groovy, que é uma linguagem com recursos muito interessantes para esta
finalidade. Por não ser a linguagem padrão, é necessário um esforço razoável para
configurar o Canoo para utilizar o Groovy.
Instalando o Canoo WebTest
1. Baixar a distribuição do Canoo WebTest
2. Descompactar o arquivo em um diretório de sua escolha. Vou assumir o diretório
c:softswebtest.
11

12. 3. Criar as variáveis de ambiente:
o WEBTEST_HOME = c:softswebtest
o JAVA_HOME = [diretório onde está instalado o JDK]
4. Garantir que os diretórios %WEBTEST_HOME%bin e %JAVA_HOME%bin estão na
lista do PATH do sistema.
5. Para verificar se a instalação foi bem sucedida, crie um diretório qualquer (vou assumir
c:mytests) e entre com seguinte comando no command prompt:
$ webtest -f %WEBTEST_HOME%webtest.xml wt.createProject testeCanoo Buildfile:
WebTestwebtest.xml wt.init: wt.createProject:[echo] [echo] Your WebTest project
[testeCanoo] has been successfully created with some demo [echo] tests to get
started. [echo] You can now just go to [c:myteststestCanoo] and run ant. [echo] BUILD
SUCCESSFUL
6. Se a execução do comando anterior gerar uma saída semelhante a esta acima, execute os
comandos a seguir: $ cd testeCanoo $ ant
7. Se após a execução do comando anterior, o arquivo
c:myteststesteCanooresultswebTestResults.html existir, o Canoo WebTest está
funcionando corretamente em seu sistema.
Criando um projeto de teste Canoo
Agora o sistema está pronto para teste canoo e começar a escrever testes Canoo. Canoo fornece
um utilitário para criar um projeto Canoo com toda a estrutura necessária.
Abra o prompt de comando e vá para sua pasta pessoal Canoo (D: Canoo) e digite:
webtest -f build/webtest.xml wt.createProject
Dê um nome para o seu projeto Canoo.
Este comando irá criar um projeto Canoo com o esqueleto necessário e também fornecer algumas
utilitários para teste padrão de seu aprendizado.
12

13. Execução dos casos de teste Canoo
Agora Canoo projeto está pronto para ser executado. Basta ir em linha de comandos e vá para o
seu projeto de casa Canoo e digite:
Webtest
Em seguida, a seguinte tela será exibida como na Imagem 1:
Imagem 1
13

14. Referências
Caetano, Introdução à Automação de Testes Funcionais. Disponível em:
http://qualidadebr.wordpress.com/2011/03/05/conheca-o-watir/. Acessado em 13/07/2013
Garcia, Introdução à Automação de Testes. Disponível em:
http://www.testexpert.com.br/?q=node/383. Acessado em 13/07/2013
IBM, Testes Funcionais. Disponível em: http://nerds-on.com/2013/03/19/automacao-de-testes7-passos-para-o-sucesso/. Acessado em 15/07/2013
Automação e Gerenciamento de Testes: Aumentando a Produtividade com as Principais
Soluções Open Source e Gratuitas. Disponível em:
http://www.testexpert.com.br/?q=node/795. Acessado em 15/07/2013 . Acessado em
15/07/2013
Canoo Web Test. Disponível em http://webtest.canoo.com/webtest/manual/WebTestHome.html.
Acessado em 15/07/2013
14