P. 1
artigoSelenium

artigoSelenium

|Views: 232|Likes:

More info:

Published by: Marcel Rodrigues dos Santos on Nov 19, 2010
Direitos Autorais:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

07/01/2014

pdf

text

original

Capítulo

2
Automação de testes funcionais com o Selenium
Ismayle de Sousa Santos, Pedro de Alcântara dos Santos Neto

Abstract The software testing is fundamental in software quality assurance. The testing can be split according with its objective. An important testing objective is the check of the product behavior. This kind of test is known as functional testing. However, the systematic execution of testing requires time and effort. Many times this activity is ignored. It is important the use os testing tools in order to automate this activity. Selenium is an example of this. It is free of charge and it can export the generated tests for a great variety of technologies, like PHP, Java and Ruby. This work presents the basic concept related to functional testing and describes how to use Selenium integrated to Java. The work also presents good practices related to software testing that can increase productivity and reusability. Resumo O teste de software é um elemento fundamental na garantia da qualidade. Os testes podem ser divididos de acordo com seu objetivo. O teste funcional, por exemplo, tem por objetivo verificar o comportamento do produto desenvolvido. Contudo, a realização do teste, de forma sistemática, exige tempo e recursos, sendo por muitas vezes desconsiderado. Assim, é importante que os testadores utilizem ferramentas que automatizem de alguma forma essa atividade. O Selenium é um exemplo de ferramenta que auxilia essa atividade. Ela tem se destacado atualmente por ser gratuita e pela possibilidade de exportação dos testes criados a partir do seu uso para as mais variadas tecnologias, como PHP, Ruby ou Java. Este trabalho apresenta conceitos básicos do teste funcional, além de descrever como utilizar o Selenium integrado à linguagem Java. A partir dessa integração serão apresentados boas práticas que podem ser aplicadas ao desenvolvimento de testes funcionais, favorecendo produtividade e reusabilidade dos testes.

2.1. Introdução
No cenário atual, em que softwares estão presentes nas diversas atividades do cotidiano e no qual os sistemas estão cada vez mais voltados para web, a qualidade exigida pelos

clientes sobre os softwares desenvolvidos se torna cada vez maior. Uma das formas mais utilizadas e recomendadas para se garantir a qualidade de software se dá a partir da realização de testes, visto que testes podem ser usados para revelar a presença de defeitos [Myers 2004]. O teste de software pode ser definido como a verificação dinâmica do funcionamento de um programa, utilizando um conjunto finito de casos de teste, adequadamente escolhido dentro de um domínio de execução, em geral infinito, contra seu comportamento esperado [Abran et al. 2004]. Assim, um teste, de maneira geral, envolve a execução de um programa com a aplicação de certos dados de entrada, examinando suas saídas, verificando se elas combinam com o esperado e estabelecido nas suas especificações. É importante ressaltar que os testes não garantem que o software não contém erros, pois para isso seria necessário testar todas as entradas válidas, o que geralmente é impossível. Ao realizarmos testes durante o desenvolvimento de software adicionamos valor ao produto, uma vez que o teste corretamente executado tende a descobrir defeitos, que devem ser corrigidos, aumentando assim a qualidade e confiabilidade de um sistema [Pressman 2006]. A falta de testes pode fazer com que o software desenvolvido seja entregue com defeitos, o que pode trazer muitos problemas, como por exemplo, prejuízos financeiros, danos físicos e até perda de vidas humanas, além de prejudicar a imagem da equipe desenvolvedora perante a empresa e desta para com o cliente. Além disso, o custo de não testar é muito maior, já que a identificação de erros se torna mais difícil e onerosa nos estágios finais do projeto e os custos para reparação crescem em uma escala elevada com o passar do tempo [Patton 2006]. Existem vários tipos de testes, cada um voltado para um determinado objetivo. Testes podem ser criados para verificar se as especificações funcionais estão corretamente implementadas (teste funcional), podendo ser executados diretamente pelos usuários finais para decidir sobre a aceitação do produto desenvolvido (teste de aceitação); podem verificar se o desempenho do software está dentro do aceitável (teste de desempenho); se ele funciona sob condições anormais de demanda (teste de estresse); se o software é adequado ao uso (teste de usabilidade); testes podem ter como objetivo mostrar que o software continua funcionando após alguma alteração (teste de regressão); se os procedimentos de instalação são corretos e bem documentados (teste de instalação); para verificar o seu nível de segurança (teste de segurança); ou para verificar seu funcionamento, a partir da liberação do produto para pequenos grupos de usuários trabalhando em um ambiente controlado (teste alfa) ou em um ambiente não controlado (teste beta) [Neto et al. 2007]. Os testes, entretanto, requerem tempo, conhecimento, planejamento, infraestrutura e pessoal especializado, sendo, portanto, uma atividade onerosa [Myers 2004]. Dependendo do tipo de sistema a ser desenvolvido, ela pode ser responsável por mais de 50% dos custos [Pressman 2006]. Para se ter uma idéia dos custos envolvidos, de acordo com um relatório publicado pelo NIST [NIST 2002], U$59.500.000.000,00 é o valor relativo ao custo de falhas em softwares desenvolvidos nos Estados Unidos, apenas em 2002. Esse mesmo relatório estima que mais de 37% desse custo (U$22.200.000.000,00) poderia ter sido eliminado se a infraestrutura para teste fosse melhorada. Uma forma de reduzir os custos da atividade de testes é a partir da automação dos testes usando alguma ferramenta apropriada. No caso dos testes funcionais, a maioria

o sistema falhará ao tentar fazer o que deveria (ou o que não deveria). Também é importante diferenciar “teste” de “depuração”. as entradas e as saídas esperadas. é preciso diferenciar três termos muito ligados aos testes de sofwtare: erro. e pode ser tão desafiador quanto o projeto do próprio software [Pressman 2006]. defeito (bug) e falha. permitindo modificações nos testes gravados sem a necessidade de re-execução do software e nova captura [Neto et al.das ferramentas disponíveis se baseia na gravação de todas as ações executadas por um usuário. 2. O projeto de casos de teste é um dos grandes desafios do processo de teste de software. a partir do uso do framework JUnit [Gamma and Beck ]. 2007]. Quanto a construção dos testes. Testes podem demonstrar falhas que são causadas por defeitos.2. Ou seja. Como exemplo desse tipo de ferramenta temos o Selenium-IDE [OpenQA b]. que pode ser usado para automatizar testes funcionais em aplicações web. Além disso. Como geralmente é impossível testar um programa exaustivamente. permitindo assim a automação do teste. Além disso. um defeito em um componente ou sistema pode fazer este falhar na execução na execução de alguma funcionalidade. será apresentada a ferramenta Bromine [OpenQA a]. 2007]. Alguns exemplos são um conjunto de passos a serem seguidos em uma interface gráfica. Neste capítulo serão apresentados alguns conceitos relacionados aos testes de softwares. Conceitos Básicos Antes de tudo. o script gerado pode ser facilmente alterado. 2006]. e as condições sob as quais o teste deve ocorrer. ou seja. gerando um script 1 com os passos realizados. Essa especificação inclui os dados de teste. que produz um defeito no código. 2006]. existem basicamente dois métodos que podem ser 1 Conjunto de instruções para um programa. Dessa forma. que foi criada para o gerenciamento de testes feitos com o Selenium. . o ser humano está sujeito a cometer um erro (engano). Um procedimento de teste é uma especificação de uma seqüência de ações para execução de um determinado teste. o conjunto de casos de teste deve ser o mais abrangente possível levando em conta qual o sub-conjunto dos casos possíveis tem maior probabilidade de exibir falhas. testar todos os possíveis casos. Um caso de teste é uma especificação de como um software deve ser testado. Assim. em especial aos testes funcionais. e uma falha corresponde a uma discrepância entre o resultado ou comportamento atual (identificado durante a execução dos testes) e o comportamento ou resultado esperado (definido nas especificações ou requisitos)[Spillner et al. Também serão apresentados os princípios gerais acerca dos testes e a utilização da ferramenta Selenium integrado com a linguagem de programação Java. Depuração é a tarefa de localizar e corrigir os defeitos [Spillner et al. Um erro ocorre devido a uma ação humana que produz um resultado incorreto [IEEE 1990]. causando possivelmente uma falha [Müller et al. um conjunto de funções a serem chamadas ou uma seqüência de requisições de página para um sistema web. Se um defeito no código for executado. as responsabilidades de cada atividade são bem distintas: testadores testam e desenvolvedores depuram. as ações gravadas podem ser facilmente re-executadas. ou seja.

Princípios dos testes Burnstein [Burnstein 2003] define princípios. Testar todos os valores possíveis para todas as entradas. O teste reduz a probabilidade que os defeitos permaneçam em um software. que tem por objetivo determinar se os requisitos foram total ou parcialmente satisfeitos pelo produto sem levar em conta como ocorre o processamento. na maioria das vezes os softwares requerem números astronomicamente altos de casos de testes. • Princípio 3: A atividade de teste deve começar o mais cedo possível. Os testes devem ser adaptados aos riscos e ambientes inerentes da aplicação. • Princípio 4: Defeitos tendem a estar agrupados.utilizados [Filho 2003]: (i) método da caixa branca. 2. como por exemplo o do computador de bordo de aeronaves. não prova que ele esteja perfeito. como sendo leis. Pode ocorrer de um mesmo conjunto de testes que são repetidos várias vezes não encontrarem novos defeitos após um determinado momento. • Princípio 2: Teste exaustivo é impossível. é muito pouco provável que os defeitos estejam uniformemente distribuídos pelo sofwtare. mas não pode provar que eles não existem. são testados diferentemente de softwares do comércio eletrônico • Princípio 7: A ilusão da ausência de falhas. a maneira como são construídos e como eles se comportam. que objetiva determinar defeitos na estrutura interna do produto. • Princípio 6: Testes dependem do contexto. e (ii) método da caixa preta. Assim. ou seja. em vez do teste exaustivo. Um conjunto de testes novo e diferente precisa ser escrito para exercitar diferentes partes do software ou sistema com objetivo de aumentar a possibilidade de encontrar mais falhas. regras ou doutrinas relativas a softwares. Para superar este “paradoxo do pesticida”. os casos de testes necessitam ser freqüentemente revisados e atualizados. 2006]: • Princípio 1: Testes demonstram a presença de defeitos. A atividade de teste deve começar o mais breve possível no ciclo de desenvolvimento do software e deve ser focado em objetivos definidos. mas mesmo se nenhum defeito for encontrado. Assim.3. efetuando todas as formas de combinação e levando em conta diferentes precondições é geralmente impossível. Encontrar e consertar defeitos não ajuda se o sistema construído não atende às expectativas e necessidades dos usuários. O teste pode demonstrar a presença de defeitos. sempre que for implementar testes. o testador deve ter em mente os princípios gerais dos testes [Spillner et al. Geralmente a maioria dos defeitos são encontrados em algumas partes do software sob teste. não a ausência. o testador deve levar em conta os riscos e prioridades do sistema sob teste para focar os casos dos testes. por meio do desenho de testes que exercitem suficientemente os possíveis caminhos de execução. Softwares de segurança crítica. . Na prática. considerando o domínio da engenharia de sofwtare. • Princípio 5: O paradoxo do perticida.

uma vez que todos os valores em uma classe de equivalência deveriam ter o mesmo comportamento. as quais detalham os casos e procedimentos de testes. Isso significa que esse teste é baseado na análise da especificação de funcionalidades do software testado [Spillner et al. portanto. O emprego dessa técnica deve ser complementar ao uso da partição de equivalência. Para utilizar a técnica do Valor-Limite no exemplo anterior. em geral. as possíveis classes de equivalência para essa entrada são: i) todos os valores inteiros menores que 1. Em um programa de cadastro de um usuário. O uso de outros valores seria desnecessário. o teste funcional é feito para verificar.4. Assim. Os testes realizados dessa forma. para representar a partição de valores abaixo de 1 (um) utilizaríamos 0 (zero). e iii) valores inteiros maiores que 12. testar vários números negativos para verificar como a aplicação se comporta. Assim. um valor entre 1 e 12. Testes funcionais de software O teste funcional é um teste para avaliar o quanto o comportamento observado do software está em conformidade com as especificações [Abran et al. 2004]. Testes manuais versus Testes automatizados Um teste manual é aquele em que o testador executa o software manualmente com base nas especificações dos testes. se o cadastro de um novo usuário em um sítio Web funciona conforme o esperado. A partição de equivalência é um método que divide o domínio de entrada em categorias de dados. Eles exigem mais tempo para implementar os testes. . Cada categoria agrupa dados que possuem as memas características e revelam uma classe de erros. por exemplo. sendo dispensável a execução de vários testes para valores pertencentes à mesma classe de equivalência. a mesma capacidade de detectar erros. Para implementar os testes de forma eficiente e evitar a construção de casos de testes desnecessários é necessário utilizar técnicas específicas para projetar os casos de testes. selecionam-se os casos de teste nas extremidades de cada classe [Filho 2003]. são aqueles feitos com auxilio de alguma ferramenta apropriada. em vez de selecionar um elemento aleatório de cada classe de equivalência. e um valor maior que 12. A seguir serão apresentadas as duas principais técnicas usadas para o desenho de testes funcionais: a particação de equivalência e a análise do valor limite. ii) valores inteiros entre 1 e 12. Assim. o mês do nascimento do usuário deve estar entre 1 e 12. potencialmente. Não é necessário. permitindo assim. mas provêem mais segurança na manutenção e permitem que os testes sejam executados a qualquer instante. são cansativos e de difícil repetição. por exemplo. que casos de teste na mesma categoria sejam eliminados sem que se prejudique a cobertura dos testes [Filho 2003]. uma vez que boa parte das falhas tendem a se concentrar próximo a esses valores. qualquer valor tem. para representar valores entre 1 e 12 utilizaríamos os números 1 e 12. 2006]. 2. um bom conjunto de teste para esse caso seria termos um valor menor que 1.5. Na Análise de Valor-Limite os casos de teste são escolhidos próximo ou nas fronteiras dos domínios de entrada. Já os testes automatizados. os valores que estão no limite entre uma classe e outra. Assim.2. Com isso. devemos selecionar como valores representantes das partições. e o número 13 seria o escolhido para representar valores na partição acima de 12. Para cada uma dessas classes.

existe a necessidade de se executar testes centenas e até milhares de vezes. a execução dos testes restantes deverá ser suspensa até que a mesma seja corrigida. que um testador projetou centenas de testes e optou por executá-los manualmente. de código aberto. sua execução é bastante simples. como existem grandes chances de que outras partes do software sejam afetadas. Se a interface de usuário da aplicação for mudar consideravelmente em um futuro próximo. Supondo. • verifyTextPresent/assertTextPresent: verifica a presença de um texto em qualquer lugar da página. A ferramenta Selenium O Selenium é um conjunto de ferramentas OpenSource3 que pode ser usada para criação de testes funcionais automatizados para aplicações Web. 5 Acrônimo para Uniform Resource Locator. Após a correção. 2 Conjunto 3 Software de testes.Antes de decidir em automatizar ou não os testes. 4 Linguagem de criação de scripts desenvolvida pela Netscape em 1995. Isso normalmente justifica a automação dos testes. tais como: • open: abre uma página usando uma URL5 que é fornecida como parâmetro. A automação de um conjunto de testes geralmente demanda bem mais esforço que sua execução manual. Assim. Além disso. • click/clickAndWait: executa o clique em um botão. dependendo da falha. • waitForPageToLoad : pausa uma execução do teste até que uma nova página seja carregada. • verifyText/assertText: verifica se um texto aparece em um determinado local. quando o software for simples e não houver tempo suficiente. é preciso analisar a aplicação testada e quais testes serão contruídos. automatizar os testes é a melhor maneira de economizar tempo e dinheiro. 2007]. Uma das suas vantagens é a possibilidade de executar os testes em qualquer navegador com suporte a JavaScript4 . se atendo a execução de um script ou o clique de alguns botões [Neto et al. 2. Se em algum momento da execução da bateria de testes2 for descoberto uma falha. Em um caso típico. ou se for improvável o reuso dos testes. em situações como a descrita. então os desenvolvedores deverão ser avisados. . Contudo. nem sempre é vantajoso automatizar os testes. então qualquer automação que for feita vai precisar ser refeita. Além disso. por exemplo. A principal razão para automação dos testes é a necessidade de re-execução dos mesmos. o testador terá que executar todos os testes novamente e novas falhas podem ser encontradas repedindo o ciclo.6. as ferramentas que compõem o Selenium provêem um rico conjunto de funções específicas para a implementação de testes. link ou imagem. Esse comando é chamado automaticamente pelos comandos com terminação “AndWait”. Além disso. então o teste manual continua sendo uma opção a ser considerada. por exemplo. mas quando automatizado. Existem situações em que realizar os testes manualmente é mais adequado.

Eles representam operações realizadas pelo usuário durante a execução de um sistema web. como o comando “storeTitle” que armazena o titulo da página em uma variável determinada por parâmetro. automatizando assim. Este possiblita uma maior flexibilidade ao testador. • Accessors: examinam o estado da aplicação e armazenam o resultado em variáveis. • select: seleciona um elemento dentre uma lista de opções. o que indica que a ação fez uma chamada ao servidor e que o Selenium deve esperar a página carregar para executar o próximo passo. reduzindo assim o tempo gasto na execução de uma suite de testes. Vale notar que as variáveis criadas no Selenium podem ser acessadas de duas formas: ${nomeDaVariável} ou javascriptstoredVars[’nomeDaVariável’]. clicar em botões. O Selenium-Grid atua executando múltiplas instâncias do Selenium-RC em paralelo de forma transparente. o conjunto de comandos do Selenium permite realizar uma série de ações necessárias para execução de testes em páginas web. selecionar itens de uma lista de opções. Como mencionado anteriormente. algumas tarefas ainda não são simples para se executar com essa ferramenta. Ele é ideal para escalonar grandes suites de testes ou suites de testes que devem ser executadas em múltiplos ambientes. Apesar da facilidade de automação dos testes com o Selenium-IDE. por exemplo. A maioria desses comandos pode conter o sufixo “AndWait”. Python. . C#. Sua instalação é simples: basta abrir o arquivo de instalação pelo Firefox. fazendo com que os testes não precisem se preocupar com a infraestrutura utilizada. O Selenium-IDE é uma ferramenta do tipo record-and-playback. PHP. entrar com valores em campos da página. Ele opera como plug-in do FireFox e provê interfaces amigáveis para o desenvolvimento e execução de suites de testes (conjunto de testes). clicar em links e realizar asserções com base nos resultados exibidos da página. Selenium-RC e Selenium-GRID. ele provê uma API (Application Programming Interface)6 e bibliotecas para cada uma das linguagens suportadas: HTML. Para esses casos deve-se utilizar o Selenium RC (RemoteControl). tais como o comando “click” que indica um clique em um determinado botão ou link. O Selenium-IDE é um ambiente de desenvolvimento integrado para construção de casos de testes. ou seja. a partir do uso de uma linguagem de programação. ela captura as ações executadas pelo testador e gera um script que permite a re-execução das ações feitas. 6 Um conjunto de rotinas e padrões estabelecidos para a utilização das suas funcionalidades. Os comandos que realizam essas ações são divididas em três grupos: • Actions: são comandos que geralmente causam uma mudança no estado da aplicação. permitindo a construção de lógicas de teste mais complexas. Ele não oferece. Atualmente as principais ferramentas que compõem o Selenium são: SeleniumIDE. Para isso. o teste. O Selenium-Grid permite distribuir os testes em múltiplas máquinas. suporte para testes com interação ou que devem ser executados com base em uma determinadas condições. tais como. Java. Perl. e Ruby.• type: entra com um valor em um determinado campo da página.

Figura 2. que representa a URL a ser acessada (alvo). e existem aqueles que não utilizam parâmetros. eles tipicamente são: i) uma identificação para algum elemento da página. . com dois parâmetros. e o comando “assertTextPresent”. Alguns exigem dois parâmetros. o comando “type”.1. pode-se usar o comando “assertText”. o alvo e o valor. ii) um texto para verificar se ele aparece na página ou para colocá-lo em algum campo da página. Já no modo “waitFor”.• Assertions: são como os Accessors. Quanto aos parâmetros utilizados pelos comandos do Selenium. o Selenium espera o texto aparecer para prosseguir a execução. Script de teste do Selenium em HTML. O número de parâmetros usados varia de acordo com o comando. “verify” e “waitFor”. O script ilustrado nesta figura. com um parâmetro. Nas próximas sub-seções serão apresentados o Selenium-IDE e a criação de testes automatizados com o Selenium-RC usando a linguagem Java e o framework JUnit. nessa ordem. Nele pode-se perceber que no formato HTML cada comando é representado como uma linha de uma tabela. A Figura 2. Para verificar a presença de um certo texto em um determinado local. indicando o texto (alvo) a ser procurado na página. por exemplo. A Figura 2. Todas as asserções do Selenium podem ser usadas de três modos: “assert”. para HyperText Markup Language. por exemplo. “verifyText” ou “waitForText”. outros exigem somente um. é formado por três comandos: o comando “open” com apenas um parâmetro.2 ilustra a página web que será utilizada como base para a maior parte dos scripts 7 Acrônimo 8 Acrônimo de Asynchronous Javascript And XML. que é muito útil para testar aplicações com Ajax7 . se a verificação falhar o teste pára. mas verificam se o estado da aplicação está conforme o esperado. Com o “assert”.1 ilustra um script de teste no formato HTML8 feito com o SeleniumIDE. Cada linha é por sua vez dividida em três células representando o comando. o primeiro representando o nome do campo a ter uma informação digitada (alvo) e o segundo contendo o texto que será entrado no campo (valor). enquanto que com o “verify” a ferramenta acusa a falha mas o teste continua executando.

de testes que serão apresentados no decorrer do capítulo. Figura 2. Uma breve introdução ao Selenium-IDE O Selenium-IDE. Ele possui uma interface amigável e exibe o script de teste como uma tabela. Página Web que servirá de base para os scripts de testes apresentados neste capítulo.2.3. A ferramenta Selenium-IDE. se tornando assim.3. . ideal para aprender a sintaxe e o funcionamento do Selenium. Figura 2. 2.1. Essa página é responsável pelo cadastro de usuários e faz parte de um sistema de administração de um sítio que segue um modelo específico da UFPI.6. é um plug-in do FireFox que permite ao testador desenvolver e executar casos de testes sem a necessidade de conhecimentos em programação. ilustrado na Figura 2.

O Selenium-IDE também provê flexibilidade ao construir os testes. Figura 2. abrir ou salvar testes e suites de testes. da página ilustrada na Figura 2.O menu “Arquivo” permite ao usuário criar.) será usada para salvar os casos de testes.4 exibe o resultado de um clique com o botão direito do mouse. O menu “Editar” contém as operações para editar os casos de testes e o menu “Opções” permite mudar as configurações da ferramenta. A Figura 2. a maioria com o parâmetro alvo pré-definido de acordo com o elemento selecionado (clicado). o alvo.6 o testador pode modificar o comando (digitando ou selecionando algum dentre os exibidos por meio do drop-down destacado na figura). Ruby. que monta o script de teste à medida que ações vão sendo feitas pelo testador. Logo abaixo do menu principal. Conforme exibido na Figura 2. como por exemplo. o valor. pode ser especificada a UrlBase. A ferramenta contém um menu que é exibido após o clique ou seleção de um algum elemento da página atual. A Figura 2. etc. e . Nesse caso é exibido um menu mostrando alguns comandos do Selenium. sobre o texto “Inserir Usuário”. e também existem opções para controlar a execução dos casos de testes.4. como por exemplo. a velocidade e a forma de execução. que será compartilhada por todos os testes.5 ilustra o funcionamento da ferramenta. Menu exibido ao clicar em algum elemento da página.2. Java. Para encerrar a gravação basta clicar no botão situado nas proximidades no canto superior direito. Começar a construir testes com o Selenium-IDE é muito simples: basta abrir a ferramenta por meio da aba “Ferramentas” do FireFox e o Selenium-IDE já começa a gravar as ações que forem feitas. o testador pode especificar o timeout (tempo limite que a ferramenta deve esperar por uma resposta) e qual linguagem (Html.

definir onde deve começar e parar a execução.6. Gravando testes com o Selenium-IDE. B) Opções disponíveis para alterar o script de teste. Além disso. copiar/excluir/remover comandos. a ferramenta permite inserir comentários. pode ser feita a partir de algum identificador. executar um único comando por vez. na qual a sintaxe do comando selecionado é descrito. . A localização dos elementos na página web. Figura 2. necessária para utilizar muitos dos comandos do Selenium (como o “type”).5. A) Visualização da descrição dos comandos.Figura 2. no caso de dúvidas ele pode consultar a API do Selenium na aba “Reference”.

Com o script da parte B da figura é fácil perceber que o teste é feito sobre a página de cadastro de usuário. por exemplo. Supondo. mencionados acima. A expressão “//form[1]”. Outra vantagem da utilização do UI-Element é a fácil visualização da descrição dos elementos.7 ilustra à esquerda um teste feito para a página de cadastro de usuários (ilustrado na Figura 2. o que dificulta a leitura do teste. ou a partir do DOM10 .do XPath9 do elemento. Algumas vezes (e não são poucas) os elementos da página testada deverão ser localizados pelo Selenium a partir de expressões XPath do tipo “//table[@width=100]//tr[3]/td[2]//a”. os elementos da página também podem ser localizados a partir de expressões do tipo “document. Esta é especificada a partir do mapeamento e é visível na aba “Reference” após clicar em algum comando que utilize um elemento previamente mapeado. Agora supondo que um testador que não tenha implementado os 100 testes. por exemplo. de Document Object Model. Quando não há o atributo “name” ou “id” para o elemento desejado. de XML Path Language. que foram implementados 100 casos de testes. o elemento pode ser identificado por meio do seu nome ou identificador (id). o nome dos campos tenha que ser alterado para “form:login” e “form:senha”. podemos observar que utilizando o mapeamento o teste fica muito mais legível e fácil de entender. se para logar for preciso preencher os campos “login” e “senha”. e que em todos eles é necessário fazer o login para acessar o sistema. todas as referências aos campos “login” e “senha” devem ser alterados para “form:login” e “form:senha”. todos os casos de testes irão se referir a esses dois elementos (identificados na página por “login” e “senha”). Com base nela. O Selenium-IDE também fornece meios para tornar os testes mais fáceis de entender e manter. refere-se ao segundo formulário da página (pois a identificação inicia do zero). como o uso de algum framework.2) feito no Selenium-IDE sem utilizar UI-Element e à direita o mesmo teste utilizando o UI-Element. Assim. Agora. Isso é possível a partir do UI-Element que é um recurso suportado tanto pelo SeleniumIDE quanto pelo Selenium-RC.forms[0]. Fazer essa alteração manualmente certamente exigiria muito tempo e toda vez que a referência a um elemento da página fosse alterada todos os testes deveriam ser atualizados. respectivamente. a qual se refere ao quarto elemento presente no primeiro formulário da página. tenha que entendê-los para saber quais funcionalidade foram testadas. 11 Acrônimo de JavaScript Object Notation 10 Acrônimo 9 Acrônimo . Por fim. então. então. ele poderia perder muito tempo tentanto identificá-los.elements[3]”. este pode ser localizado usando-se xPath que inicia com “//”. É bom lembrar que nem sempre será possível se referir a um elemento usando algum termo que permita a sua fácil identificação. No caso de um campo ou formulário. para tornar os testes mais legíveis e fáceis de atualizar. o testador pode usar mapeamentos utilizando JSON 11 entre nomes e os elementos da página sob teste. supondo que por algum motivo. Nesse caso. A Figura 2. que após a preenchimento dos campos foi pressionado o botão “Cadastrar” e que o resultado esperado é uma mensagem com o texto “Usuário Cadastrado”. dependendo de como for feita a referência aos elementos da página.

links.js” com mapeamento feito usando os comandos reconhecidos pelo UI-Element. A) Exemplo de teste sem UI-Element. Essas descrições tornam o teste ainda mais claro. Deve ser definido o nome.7. B) Mesmo teste da esquerda com UI-Element. Também existem outros atributos que podem ser definidos. A Figura 2. Os comandos que podem ser utilizados para criar o mapeamento através do UIElement são: • addPageSet: para adicionar uma página ou conjunto de páginas que contém os elementos que serão usados no teste. como por exemplo.8 ilustra a descrição associada ao “elemento cadastroUsuario::mensagemExibida”. Mais comandos podem ser encontrados através do menu “Ajuda” do 12 Componente do Selenium responsável por executar os comandos do Selenium no browser . esse arquivo deve ser submetido como extensão do Selenium Core12 a partir do menu “Opções” do Selenium-IDE. A primeira linha do mapeamento deve seguir a estrutura “var nomeDaVariavel = new UIMap()”. localizado no terceiro div da página (pois seu locator é “//div[2]”). pode-se especificar uma expressão regular para indicar o path das páginas que pertencem ao grupo em questão a partir do atributo “pathRegex”. Em seguida. imagens. • addElement: para adicionar os elementos (campos. Para cada conjunto deve ser especificado o nome e a descrição. a qual é definida no parâmetro “locator”. Para construir o mapeamento entre nomes e elementos basta usar um editor de textos e criar um arquivo no formato “. a descrição e a localização do elemento. permitindo que o mesmo seja rapidamente compreendido.Figura 2. dentre outros) das páginas. botões.

por exemplo. A parte B da Figura 2. A partir da definição das regras de agrupamento (Rollup rules). é interessante usar algum meio para agrupar tais sequências. então basta atualizar o atributo “pathRegex” do conjunto de página (Pageset) nomeado de “cadastroUsuario” e o atributo locator do elemento “linkUsuario” para que todos os testes da página de cadastro de usuário sejam atualizados. Por fim. muitas vezes existem sequências de comandos que são executadas mais de uma vez em um mesmo teste. o testador pode reunir comandos em grupos possibilitando que eles sejam invocados com o comando rollup.9 ilustra o mapeamento que foi utilizado no teste exibido na parte B da Figura 2. Também existem sequências de comando que são executadas em mais de teste. Observe que se a localização (ou forma de identificação) dos elementos for alterada. Já para o Selenium-IDE é preciso usar o “Rollup”. Selenium-IDE.10 ilustra um teste que utiliza o comando rollup para efetuar a sequência de comandos do grupo identificado por “login”. A parte A da Figura 2. Se o endereço da página de inserção de usuário for alterado.10 ilustra a definição de regras de agrupamento para reunir uma sequência de comandos em grupo identificado por “login”. Visualização da descrição dos campos por meio do UI-Element. usando os mesmos parâmetros ou não. possibilitando a invocação de toda a sequência com um único comando. Assim. Com Selenium-RC. que podem pertencer ou não a uma mesma suite de testes. que efetua o login em uma página web.Figura 2. A Figura 2.8. o agrupamento de comandos pode ser facilmente feito a partir de blocos. . basta atualizar o atributo “locator” para que todos os testes estejam atualizados.7.

o principal atributo é o getExpandedCommands o qual especifica quais serão os comandos a serem executados. além de poder tratar dinamicamente os resultados dos testes. Mapeamento feito para os elementos da página exibida na Figura 2. Existem vários atributos que podem ser definidos. Escrevendo testes com o Selenium RC e a linguagem Java Como mencionado anteriormente.9.js” e da submissão desse arquivo como extensão do Selenium Core a partir do menu “Opções” do Selenium-IDE.Figura 2.2. Ele pode. A criação dos arquivos com os “Rollup rules” é feita da mesma forma que a definição do mapeamento descrito acima. nesse caso a primeira linha deve seguir a estrutura “var nomeDaVariavel = new RollupManager()” e o único comando disponível é comando “addRollup”. a partir da criação de um arquivo no formato “. Porém. ou seja. por exemplo.2. ler e escrever em arquivos. trabalhar com iterações. expressões condicionais. com o Selenium-RC o testador pode construir testes utilizando todo o poder fornecido pela linguagem de programação utilizada. 2.6. . No script ilustrado. usado para adicionar uma nova regra.

O Selenium-RC é constituído de dois componentes principais: Selenium Server. Assim. Bibliotecas.11 exibe um script de teste no formato HTML feito com o Selenium-IDE para o cadastro de usuários da página exibida na Figura 2. Observe que as cinco primeiras linhas do script exibido na figura . a partir do qual os comandos acionados são transmitidos e executados no navegador selecionado. A maneira mais fácil de iniciar a criação de testes funcionais automatizados utilizando Selenium e Java é criando primeiro um script (com a “estrutura” geral do teste) utilizando o Selenium-IDE. conjunto de instruções que são acionadas e que causam uma comunicação com o Selenium Server.da abertura da página “/modelo/admin/index.Figura 2. o teste com o Selenium também deve realizar os procedimentos necessários para efetuar o login. . ponte para o navegador. A) Definição das Rollup rules. Isso porque para cadastrar um usuário é preciso fazer antes o login no sistema. as ações necessárias para efetuar o login também devem ser inseridas no script de teste para que ao executar a sequência de comandos do teste se tenha acesso a página de cadastro de usuário.2.estão associadas ao login no sistema. e como o usuário deve logar para ter acesso as funções administrativas do sistema.php” até a verificação do texto “Sair” .jar”) e para que os comandos do Selenium sejam reconhecidos é necessário acrescentar a biblioteca referente a esta linguagem ao projeto que contém o teste. É bom lembrar que o Selenium simula um usuário acessando a aplicação. para executar testes feitos com o Selenium e alguma linguagem de programação é preciso iniciar o servidor (“selenim-server. B) Teste usando o comando rollup. A Figura 2.10. Logo.

ou seja.11. Script de teste da Figura 2. Figura 2. Isso é feito a partir do menu “Opções > Formato > Java (JUnit) SeleniumRC”. converter os comandos do script nas funções disponíveis na API para a linguagem Java. Como o teste utiliza a API do Selenium para o Java é preciso adicionar a biblioteca da API Java (selenium-java-client-driver.Figura 2. Caso o testador queira executar os testes no TesteNG ele deve usar a opção “Opções > Formato > Java (TestNG) SeleniumRC’.jar) ao projeto .12.11 é exibido na Figura 2. podemos utilizá-lo a partir do conjunto Eclipse+JUnit para concluir a automação dos testes. O próximo passo é converter script do formato HTML para Java. para o framework JUnit. O resultado da exportação.11 exportado para Java (JUnit). Após termos o arquivo Java. Script de teste feito com o Selenium-IDE. do script ilustrado na Figura 2.12.

Considerando que a mesma situação ocorre durante o cadastro de um usuário.13. Com isso. Visualização do teste exportado no Eclipse. Por fim. gerando assim erro de compilação no teste.14. podemos passar a variável Selenium por parâmetro. Esse destaque indica que o comando não foi reconhecido. eles ficarão em destaque conforme exibido na Figura 2. os campos login e senha não forem corretamente preenchidos aparecerá na tela do sistema considerado uma mensagem de alerta (alert) indicando o erro. Para isso basta criar funções específicas reunindo os comandos de acordo com as ações deles e substituir os valores utilizados por variáveis. Assim. caso contrário.13. teremos os procedimentos escritos conforme a Figura 2. Assim. Na Figura 2. Em seguida.com o teste para que os comandos sejam reconhecidos. deve-se concluir a implementação dos procedimentos de testes. podemos concluir a implementação da função login acrescentando mais uma variável que armazenará o erro (mensagem do alerta) esperado. Para que a instanciação do Selenium seja feita somente na classe com os casos de testes.15. 13 Documentos que descrevem os casos e procedimentos de testes. Vale lembrar que é preciso instanciar uma variável do tipo Selenium para ter acesso as suas funções. . podem ser criados duas funções: login (que efetua o login na página) e cadastroUsuario (que cadastra um usuário no sistema). para o script da Figura 2. Figura 2. Se no login. de forma que eles também sejam utilizados para verificar se as operações vão falhar quando deveriam.13. resta implementar os casos de teste utilizando para isso os procedimentos de testes que foram implementados e as especificações de testes13 . nossa classe com os procedimentos de teste fica como exibido na Figura 2. O passo seguinte consiste na construção dos procedimentos de testes parametrizados. por exemplo.16 apresentamos alguns casos de teste criados para verificar o login e o cadastro de usuários do sistema.

Na primeira execução da suite de testes. sem restaurar o banco de dados para o estado original. indicando que nenhuma falha foi detectada. eles passaram porque não havia o usuário “Usuário de teste”15 cadastrado no sistema. e no lado B a reexecução dos mesmos. . o sistema não permitiu o cadastro do mesmo usuário. ou seja. a barra de execução ficou verde.jar". Os testes criados com o Selenium são testes que utilizam o JUnit. Classe com o procedimento de teste parametrizado. Enquanto que no lado B. com a re-execução da mesma suite de teste. portanto. de forma similar aos testes de unidade. Sua execução acontece da mesma forma que os testes de unidade. Isso porque no último teste. a barra de execução ficou vermelha pois o execução do último teste encontrou uma falha. Sua execução pode ser feita via comando “java -jar seleniumserver. no resultado esperado pelo teste. Observe que no lado A da figura. clicando com o botão direito do mouse em cima da classe e solicitando sua execução via JUnit.Figura 2. 14 Servidor 15 Nome do Selenium. Assim.jar 14 . A Figura 2.14. é necessário que exista uma instância do Selenium Server executando na mesma máquina que contém os testes que serão executados. antes de executar os testes é preciso executar o arquivo selenium-server. do usuário contido no script de teste. existe uma diferença: para que o teste execute. não resultando. que pode ser baixado no site do Selenium. No entanto. o resultado esperado é a mensagem “Usuário Cadastrado”. o teste passou.17 exibe o resultado da execução dos testes apresentados neste capítulo. Contudo. O lado A da figura apresenta a primeira execução dos testes. no qual é feito o cadastro de um novo usuário.

Este por sua vez ofecere características próprias que podem ser utilizadas para facilitar a implementação dos testes. Assim como no Selenium-IDE. porém neste só é possível adicionar um arquivo de mapeamento e ele deve ser chamado de “user-extensions.jar -userExtensions user-extensions. basta executar o servidor com o comando “java -jar selenium-server. por exemplo.jar”.js” para que o mapeamento seja reconhecido e dessa forma o procedimento de cadastro de usuário. . Vale salientar que também é possível implementar e executar casos de teste escritos com o Selenium utilizando a linguagem Java a partir do framework TestNG. pode ser escrito conforme exibido na Figura 2.18. A escolha do framework a ser utilizado deve ser baseado nos conhecimentos da equipe de teste e nos recursos que tais ferramentas oferecem.15. o mapeamento feito com o UI-Element também pode ser usado com o Selenium-RC. Classe com o procedimento de teste completo.Figura 2. Com isso.js” e deve estar no mesmo diretório do “selenium-server.

Classe com os casos de testes. A) A execução dos testes não encontrou falhas. . B) A execução dos testes encontrou uma falha.17. Figura 2.16.Figura 2.

Por padrão a ferramenta já vem com um exemplo de projeto para testes na página de busca do Google.openqa. Após efetuar o login no sistema. 2.) e navegador. 17 http://wiki. Figura 2. facilita a execução de testes em múltiplas combinações de Sistema Operacional (S.Figura 2. O processo de instalação da ferramenta pode ser encontrado no site da própria ferramenta 17 . Tela principal do Bromine. possibilidade de executar testes com várias instâncias do Selenium Server espalhadas por vários computadores. com senha e login igual a admin.20. para criar um novo projeto. A Figura 2. armazenamento de todos os comandos executados. exibido na Figura 2. em que deve ser feito o login16 . facilitando o gerenciamento dos mesmos. possibilidade de criar grupos e usuários restringindo as suas permissões de acesso. Dentre as características do Bromine estão: suporte a testes em Java e PHP.7.18.19.19 exibe a tela principal da ferramenta. . o primeiro passo para utilizar a ferramenta é acessar o painel de controle. Usando mapeamento de interface de usuário com o Selenium-RC. As principais vantagens desta ferramenta se referem ao armazenando dos resultados dos testes para análises e a forma menos técnica de apresentação e execução dos testes.org/display/BR/Installing+Bromine. Bromine: uma ferramenta para gerenciamento de testes Seleneses Bromine é uma ferramenta que permite a fácil visualização e execução de testes usando o Selenium RC.O. 16 Por padrão já vem cadastrado o usuário admin.

indicando assim que há uma instância ativa do Selenium RC na porta 4444 da máquina. onde encontram-se os menus “Planning” e “TestLabs”.0. e os relacionamento entre eles. Especificando requisitos no Bromine. o que vai depender da configuração dos nós que foram adicionados.21. A partir do menu “Planning” pode-se especificar os requisitos e os casos de testes.20. os projetos. Vale lembrar que no caso de só a máquina local ser utilizada para executar os testes deve-se adicionar um nó com o path sendo 127.Figura 2.21 exibe a adição de um requisito ao projeto criado.0. Observe que nele é especificado a(s) plataforma(s) onde os testes serão executados. o próximo passo é definir o planejamento dos testes. A Figura 2. os usuários e permissões. Para isso deve-se clicar no botão do canto superior direito da página para acessar o workspace. . Figura 2. É no painel de controle que são definidos os nós (máquinas nas quais há uma instância do Selenium RC executando). ou seja.1:4444. a associação entre casos de testes e o(s) requisito(s) que eles atendem. além de outras configurações que não são descritas aqui. Feitas as configurações necessárias. Painel de Controle do Bromine.

além de facilitar o gerenciamento dos testes feitos com o Selenium.8. ferramentas apropriadas e pessoal especializado. Adicionando casos de testes no Bromine. foi feita uma breve descrição sobre o Bromine. foi apresentado o Selenium-IDE e foi descrito em detalhes a automação de testes funcionais utilizando o Selenium.A Figura 2. pode-se descrever o que o teste faz. a ferramenta Selenium é uma boa opção por ser gratuita e por permitir o uso de linguagens de programação como Ruby ou Java. 18 Esse .org/display/BR/Creating+a+testscript. No caso dos testes funcionais para aplicações Web. Por conta disso. uma ferramenta que permite a distribuição da execução da suite de teste entre várias máquinas (nós). script deve estar no formato apropriado para ser reconhecido pelo Bromine. Além de adicionar o script do caso de teste18 . Além disso.22 exibe a tela onde é feita a adição dos casos de testes. Por fim. muitas vezes essa atividade só é possibilitada a partir do uso de ferramentas que permitam a automação dos testes. Figura 2. Contudo. 2. Neste trabalho apresentamos os princípios e os principais conceitos ligados aos testes de software. a linguagem de programação Java e o framework JUnit. como também existe a possibilidade de detalhar os passos do caso de teste. para detalhes deve-se consultar o site http://wiki.openqa. essa é uma atividade onerosa.22. A partir do menu “TestLabs” é possível executar os scripts de testes que foram submetidos ao Bromine. assim como visualizar os resultados dos testes a partir de gráficos na forma de pizza. Conclusões A atividade de testes é essencial para garantir a qualidade dos produtos de software desenvolvidos. pois exige tempo.

610. Technical report. V. and Veendendal. P. 2004] Abran. McGraw-Hill. http://seleniumhq.. F. Friedenberg. A. [Patton 2006] Patton. (2006).org/projects/ide/.Piaui. New York. P. IEEE Computer Society.org. (2003).IEEE Std. P. [Burnstein 2003] Burnstein. http://seleniumhq. último acesso em 10/10/2009. OpenQA. L. [OpenQA b] OpenQA. S.. and Schaefer. H. R. Engenharia de Software. National Institute of Standards and Technology.. (2007). Selenium-ide: Integrated development environment for selenium tests. R. Engenharia de Software: Fundamentos. de Sousa. D. [Spillner et al. Planning report 02-3. (2004). OpenQA.. Dupuis. JUnit. T.. Junit testing framework. [Gamma and Beck ] Gamma. John Wiley & Sons. (2003). Foundation Level Syllabus. Bromine: A web-based qa tool for selenium. Linz. [OpenQA a] OpenQA.Maranhão . and Beck.org/projects/bromine/. Technical report. E. and Resende. Technical report. Software Testing.. Guide to the Software Engineering Body of Knowledge. 2nd edition. 2006] Spillner. último acesso em 10/10/2009. G.org/.gov/director/prog-ofc/report02-3.pdf. Bourque. Sams Publishing. [IEEE 1990] IEEE (1990). T. W. IEEE Standard Glossary of Software Engineering Terminology . Base de Conhecimento para Certificação em Teste..junit. http://www. K.. J. Graham. editors (2004). (2006). Acessado em setembro de 2009. Technical report. A. 2007] Müller. (2007).. R. 2nd edition.. IEEE Computer Society. Métodos e Padrões. [Müller et al. Software Testing Foundations. E.. Moore.. I. R. and Tripp. The Art of Software Testing. [Myers 2004] Myers. Fortaleza. (2006).nist. V. 2007] Neto. http://www. 2nd edition. último acesso em 10/10/2009. D. . rockynook.Referências [Abran et al. Springer-Verlag. [Pressman 2006] Pressman. [Neto et al. 2nd edition. [NIST 2002] NIST (2002). 6th edition. Automação de Teste de Software. [Filho 2003] Filho. Practical Software Testing.12-1990. LTC. Escola Regional de Computação da SBC Ceará .

You're Reading a Free Preview

Descarregar
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->