Posts com a tag ‘selenium’

Encontrando os elementos de uma página com o Selenium

9 de fevereiro de 2009

Como já disse em outro post, um comando do Selenium é composto por uma ação e parâmetros. Na grande maioria dos comandos, o primeiro parâmetro é usado para especificar um locator. O locator é uma forma de selecionar um elemento html da página, por exemplo um botão, uma div, um link ou qualquer outra tag html.

O Selenium disponibiliza diversas formas de selecionar um elemento e para isso, um locator deve ser escrito da seguinte maneira:

tipo=expressao

Usando a própria nomenclatura da documentação, o tipo de um locator pode ser:

  • id
  • name
  • identifier
  • link
  • dom
  • xpath
  • css

Para exemplificar cada locator, vamos tomar como base o seguinte código html:

<html>
<head>
 <title>Locators no Selenium</title>
</head>
<body>
 <div id="menu">
  <ul>
   <li><a href="/">Home</a></li>
   <li><a href="/contato" title="Acesse a pagina de contato">Contato</a></li>
  </ul>
 </div>
 <div id="search">
  <form action="/">
   <input type="text" name="s"/>
  </form>
 </div>
</body>
</html>

O locator id é utilizado apenas para encontrar elementos com o id especificado. No nosso exemplo, para você verificar que a div com id menu existe, você tem que usar o seguinte comando:

verifyElementPresent id=menu

O locator name é parecido com o anterior, porém como o próprio nome diz, é utilizado para selecionar elementos que tenham o atributo name especificado. Por exemplo, digite selenium no elemento com name s:

type name=s selenium

O locator identifier é uma junção entre os dois locators anteriores. O Selenium primeiramente tenta encontrar um elemento pelo id. Se não encontrar ele tenta localizar um elemento pelo atributo name.

verifyElementPresent identifier=menu
verifyElementPresent identifier=s

O locator link é utilizado para selecionar links na página pelo texto de exibição. Geralmente ele é utilizado com o comando click.

click link=Home

Com o locator dom, você seleciona os elementos com expressões Javascript. Você pode tanto acessar o elementos pelo objeto document, como também pode escrever uma função que retorne um elemento.

verifyElementPresent dom=document.forms[0]
verifyElementPresent dom=function getMenu(){ return document.getElementById(‘menu’); } getMenu();

Com o locator xpath, é possível selecionar os elementos via Xpath. Essa forma é muito poderosa pois o Xpath foi criado exatamente para buscar elementos em um documento XML e por isso há diversas funções que facilitam isso. Em outro post vou detalhar mais sobre o que é possível fazer com Xpath. No exemplo abaixo, utilizei a função contains para pegar o link que contenha no title a string “Acesse”:

verifyElementPresent xpath=//a[contains(@title,'Acesse')]

O locator css deve ser usado por quem tem familiaridade com CSS Selectors. Esse tipo de expressão é bem parecida com o Xpath e é tão poderosa quanto. A diferença é que é uma sintaxe mais voltada para um documento HTML.

verifyElementPresent css=#menu

Agora que você aprendeu quais são os tipos de locator que o Selenium interpreta, vou contar uma dica. Os locators dom, xpath e identifier não precisam ser explicitados, ou seja, você pode inserir a sua expressão sem escrever “tipo=” e se ela começar com “document.” será interpretada pelo locator dom. Se começar com “//” será interpretada pelo xpath. E se não começar com nenhum dos dois, será interpretada pelo identifier.

Exemplos:

verifyElementPresent document.getElementById(‘menu’)
verifyElementPresent //div[@id="menu"]
verifyElementPresent menu

Como os locators identifier e xpath são os mais usados, na grande maioria dos testes você não vai precisar explicitar o locator.

Para quem quiser brincar e ver funcionando todos esses locators, eu criei um teste selenese que verifica os elementos da página usando todos os tipos de locators. Baixe-o aqui. O teste vai abrir uma página com o mesmo código html de exemplo no começo do post.

Para facilitar nossa vida, a IDE possui um botão chamado find que ao ser clicado destaca em verde o locator na página. Isso ajuda muito quando se está criando um novo teste, ou até mesmo corrigindo um antigo e você quer identificar se está selecionando o elemento certo.

Bom, é isso aí galera. Qualquer dúvida só perguntar que o seu Enium responde :)

Como rodar os testes do Selenium no IE ou em outro browser?

20 de janeiro de 2009

Até agora falei mais sobre os comandos do Selenium, e os exemplos que dei eram pra ser testados pela IDE. Como a IDE ainda só existe para o Firefox, os testes até então eram pra ser executados somente no Firefox. Mas e se você quiser testar no Internet Explorer 6? ou no 7? Ou no Safari? Ou até mesmo no browser mais recente do Google?

Aí que entra o servidor do Selenium. Você sobe um e escolhe em qual browser quer testar.

No site e na documentação do Selenium, o servidor é chamado de Selenium Remote Control, ou para os mais íntimos somente RC. Para baixar o servidor acesse http://seleniumhq.org/download. A última versão disponível é a 1.0 beta 2. Dentro do arquivo zipado, você vai encontrar uma pasta com o nome selenium-server que corresponde ao próprio servidor do selenium. As outras pastas com o nome client-driver correspondem às bibliotecas de cada linguagem disponível para comunicar com o servidor, que são:

  • Java
  • Ruby
  • Python
  • Php
  • Perl
  • .Net

Não vou me aprofundar muito sobre essas bibliotecas, mas gerar um teste em uma determinada linguagem é algo relativamente simples. A IDE tem uma opção de exportar os testes. Basta abrir um teste, clicar em file, export test case as, e escolher a linguagem desejada.

Mas não se assuste, você pode rodar o seu teste em outro browser sem a necessidade de exportá-lo para uma linguagem.

O pré-requisito para isso é ter o Java instalado na sua máquina.

O primeiro passo então é salvar o seu teste da IDE em uma determinada pasta. Só por curiosidade, na documentação do Selenium, um teste salvo pela IDE está no formato selenese. Após isso, entre no console (shell, cygwin, DOS) e vá até a pasta onde encontra-se o servidor do Selenium. Você vai ter que executar o seguinte comando:

java -jar selenium-server.jar -htmlSuite <browser> <startURL> <suiteFile> <resultFile>

Vou explicar os parâmetros desse comando de trás pra frente.

O parâmetro resultFile indica o arquivo em que será gerado o relatório do teste.

O suiteFile indica o seu arquivo selenese gerado pela IDE. O único problema é que ele tem que ser um suite e não um test case.

O parâmetro startURL indica a url do site a ser testado.

E por último nessa lista, mas o primeiro parâmetro do comando, está o browser. O valor que você tem que colocar nesse parâmetro, pode ser:

  • *firefox
  • *chrome
  • *iexplore
  • *iehta
  • *safari
  • *opera
  • *googlechrome

Detalhe é que o asterisco faz parte dos valores. O valor *chrome chama o próprio Firefox enquanto que o *iehta chama o IE. Mas há uma leve diferença entre eles. O *chrome e o *iehta são cross-domain, o que faz com que o Selenium não tenha problemas caso o fluxo do seu teste seja redirecionado para outro domínio. Eles também dão mais poder para o Selenium não se esbarrar em problemas de segurança dos browsers.

Na próxima versão do Selenium, *firefox será sinônimo para *chrome e assim o mesmo para *iexplore. Portanto, dê preferência para utilizar *chrome e *iehta.

Ao passar uma dessas strings para o servidor do Selenium, ele irá em busca do executável do browser procurando pelo path default de instalação. No Windows XP, por exemplo, passando como parâmetro o valor *chrome, o Selenium vai procurar por “C:\Program Files\Mozilla Firefox\firefox.exe”.

Mas e se você instalou o Firefox em outro path, sem ser o default? É simples, basta indicar a string do browser seguida do path completo para o executável, por exemplo “*chrome c:\firefox\firefox.exe”. As aspas duplas aqui não estão por acaso, você vai ter que colocá-las quando quiser especificar o path. Esse esquema de passar onde browser está instalado é muito útil quando você tem mais de uma versão do mesmo browser instalada na máquina.

A lista dos browsers suportados você pode encontrar aqui.

Caso você queira testar em um browser não suportado, o Selenium aceita a string “*custom” que funciona como um coringa.

Criei um arquivo de teste para que você possa comprovar que tudo isso funciona, ehehe. Você vai precisar baixar dois arquivos: o suite e o test-case. Salve-os no C: e depois rode o seguinte comando:

java -jar selenium-server.jar -htmlSuite *iehta http://www.seuenium.com.br c:\teste-suite.html c:\result.html

Depois abra o arquivo result.html para conferir o resultado da execução:

Bom, é isso aí galera… Qualquer dúvida só perguntar.
:)

AJAX e Selenium

20 de dezembro de 2008

A pessoa que quer criar um bom teste com o Selenium, precisa ter alguns conhecimentos sólidos em:

  1. Html
  2. Xpath
  3. Ajax
  4. Sistema como um todo

Neste post, vou me aprofundar apenas com o conhecimento de AJAX. Isso mesmo, apenas conhecimento, já que o testador não precisa saber nada de implementação de AJAX.

AJAX é uma forma de fazer uma requisição ao servidor sem que seja necessário dar um reload completo na página. Essa requisição assíncrona, na grande maioria das vezes, manipula o html que está sendo exibido para o usuário. O testador primeiramente precisa identificar essa requisição AJAX e para isso, a forma mais fácil é instalar a extensão do Firebug no Firefox e identificar as requisições através da aba console. Após essa identificação, o testador precisa entender o que foi alterado no Html, para depois inserir alguns novos comandos no Selenium.

Para deixar essa explicação mais fácil de entender, resolvi criar uma página que faz AJAX. Clique aqui para visualizá-la.

Na tela é preciso selecionar um estado e uma cidade, e em seguida clicar no botão salvar que redirecionará para uma tela de sucesso. Caso nenhuma cidade for selecionada, aparecerá uma mensagem de erro.

Se você abrir a IDE e sair navegando pela tela, clicando em SP, São Paulo e depois em salvar, você verá a tela de sucesso. Os comandos criados pela IDE foram:

Apenas o último comando não foi criado automaticamente pela IDE. Eu coloquei o comando verifyText para validar que a mensagem de sucesso está aparecendo com a cidade que foi selecionada.

Até aí tudo bem. Mas se você quiser rodar o teste novamente, ele falhará:

Link do teste

Apareceu a mensagem de que nenhuma cidade foi selecionada porque o Selenium rodou tão rápido que clicou no botão salvar antes que as cidades do estado selecionado fossem carregadas via AJAX.

O que tem que ser feito para corrigir esse problema?

Como disse anteriormente, é preciso identificar o que foi alterado no html com a requisição AJAX. Nesse exemplo, há uma div com id div_cidades que no momento em que a página é carregada ela fica vazia. Ao selecionar um estado, o AJAX é acionado e preenche essa div com uma tag select contedos as.

Depois dessa identificação, vamos então acrescentar o comando do Selenium para corrigir isso. O comando waitForElementPresent é o ideal para esses casos. Ele fala pro Selenium esperar para executar o próximo passo até encontrar um determinado elemento na página. No nosso caso, é falar pro Selenium esperar a tag select que está abaixo da div com id div_cidades.

O teste corrigido fica assim:

Link do teste

Existem outros comandos de wait. Todos começam com o prefixo waitFor. Dê uma olhada na documentação ou na própria IDE, já que se você digitar waitFor, vai vir a lista de todos os comandos que começam com esse prefixo.

Esse mesmo tratamento com os comandos waitFor também podem ser aplicados se há uma chamada Javascript demorada, mesmo que ela não faça uma requisição AJAX.

Ok, mas o que acontece se o elemento esperado não aparecer?

O Selenium tem uma configuração que é o tempo máximo que ele fica esperando. Se esse tempo for excedido o Selenium retorna um erro de timeout. O padrão são 30 segundos, mas você pode alterar isso na IDE, “options > options > Default timeout value of recorded command”. Se você não está usando a IDE e está subindo um selenium server, há também uma configuração para setar o timeout.

Bom galera, é isso aí. Qualquer dúvida ou sugestão é só comentar no blog.

Valeuuuuu!!!!

:)

Primeiro Post, Primeiro Teste com a Selenium IDE

15 de dezembro de 2008

Esse é o meu primeiro post nesse blog, e como é a primeira vez, estou me familiarizando com a ferramenta wordpress.

Esse também é o primeiro passo que você deve fazer para conhecer o Selenium. Familiarize-se com os seus recursos. Instale a IDE no Firefox e brinque de criar testes bobos, só para aprender os principais comandos.

O Selenium é uma ferramenta para criar e executar testes automatizados em websites. A pessoa que quer criar um teste pode apenas abrir a IDE, sair navegando pelo site e salvar um arquivo, sem se preocupar com quais comandos foram criados.

Mas aí que está o problema. Se você não se preocupar com os comandos que a IDE gera, você nunca vai entender o Selenium corretamente e seu teste criado pode:

  1. Retornar resultado falso-positivo
  2. Quebrar na próxima execução
  3. Ser muito sensível a qualquer alteração de template
  4. Ser difícil de corrigir

No caso 1, o Selenium retorna que tudo executou com sucesso (tudo verdinho), porém o seu teste não fez o que tinha que fazer. Por exemplo, imagine que você tem que testar um formulário de cadastro de usuário. Você preenche tudo no formulário e em seguida clica no botão salvar e é redirecionado para uma tela de sucesso. Mas você não notou que o campo não obrigatório “complemento do endereço” que você preencheu, não foi salvo. Somente validar que foi redirecionado para tela de sucesso não é suficiente. Você tem que validar que todos os dados preenchidos no formulário foram cadastrados corretamente e os não preenchidos continuam não preenchidos.

No caso 2, imagine que você tem um campo que não pode repetir, por exemplo, login do usuário, e o seu teste é para validar a criacão de um usuário com sucesso. Se você rodar o teste novamente, vai dar erro informando que o login já existe. Há três formas de lidar com isso. A primeira é resetar o banco na hora do teste. A outra é remover o usuário após o teste. E a última é utilizar um valor randômico para concatenar com o login do usuário. Eu acho que essa última é a mais simples, já que dá para fazer alguns truques com o comando storeExpression.
Há um outro caso em que um teste pode não rodar numa segunda vez. Isso ocorre quando há uma requisição AJAX. A IDE não reconhece essa requisição e para isso você tem que usar alguns comandos de wait. Isso é bastante importante e depois vou dedicar um post somente sobre isso.

O caso 3 acontece quando a IDE salva os comandos utilizando a árvore DOM, ou seja, ela identifica os elementos do html pela sua estrutura a partir da raiz, por exemplo, /html/body/div/h1. O ideal é o Selenium utilizar os atributos name e id. Issso porque se futuramente você quiser mudar o layout da sua página e tiver que colocar uma segunda div no path anterior, o seu teste vai quebrar já que ele está baseado no DOM. Às vezes vale a pena você alterar o seu html apenas para acrescentar um id para facilitar o seu teste. Com isso você garante uma vida mais longa para esse teste não quebrar.

No caso 4, como a IDE grava tudo o que você faz e você não dá atenção para isso, quando mais frente seu teste estiver quebrando (vermelhinho), você perderá muito tempo só para entender o que exatamente está quebrando. Por isso comente o que você está fazendo. Há uma opção na IDE para fazer isso. Botão direito em cima de um comando e “Insert new Comment”. Vai ficar algo assim:

screenshot-selenium-ide

Bom, acho que é isso aí. Algumas dicas sempre são boas.

Continuarei postando sobre testes automatizados, integração contínua e n outras coisas. Até lá.