Universidade Federal de Campina Grande – UFCG
Centro de Engenharia Elétrica e Informática - CEEI
Departamento de Sistemas e Computação - DSC
Curso de Ciência da Computação
Disciplina: LES
Equipe: David Candeia
Everton Leandro
Felipe Leal
Index
Selenium ... 3
Selenium-IDE... 4
Remote Control ... 5
Modo Interativo ... 6
Testes com JUNIT ... 7
Selenium Grid ... 9
Conclusão... 10
Selenium
Selenium é um framework para desenvolvimento de testes funcionais de aplicações, podendo esse desenvolvimento se dar em contato direto no browser ou através de códigos de programação seguindo, por exemplo, o estilo de testes do JUnit. A idéia é simular o usuário interagindo com a página da aplicação. O Selenium é uma ferramenta open-source, já com suporte a web 2.0, e que apresenta suporte a vários browsers bem como vários SOs.
Temos basicamente três modos de operação no Selenium, com o Selenium Grid sendo praticamente um complemento ao Remote Control:
• Core - para fazer testes mais simplificados
• Remote Control - para fazer testes mais elaborados
• Selenium IDE - para fazer testes através de uma interface simples que auxilia na familiarização com o framework
• Selenium Grid – permite que vários servidores RC sejam acessados em paralelo por um ou mais processos.
Ainda podemos utilizar o plugin Selenium-IDE para firefox para desenvolver testes mais rápido. Essa é a melhor forma de conhecer o básico de Selenium (veja o vídeo
http://wiki.openqa.org/download/attachments/400/Selenium+IDE.swf?version=1).
Os testes de interface sempre consumiram bastante tempo dos testadores, pois esse tipo de teste na maioria das vezes era feito manualmente, o que tornava essa atividade bastante dispendiosa, o a introdução da ferramenta Selenium essa dificuldade tem sido minimizada, por isso essa ferramenta tem se popularizado entre os testadores.
Selenium Core
A idéia básica por trás do selenium core é fazer com que tanto os scripts de testes, o Selenium Test Runner e sua aplicação sofram deploy no mesmo servidor. Assim, após o deploy deve-se abrir uma dada url para que o conjunto de testes criados sejam executados. Os testes são elaborados em HTML seguindo uma linguagem chamada pelos autores de "Selenese". Cada comando dessa linguagem segue o seguinte template:
Command target Value
Temos a seguir um alguns exemplos de comandos que podem ser usados (http://selenium.openqa.org/reference.html):
MyTest
open /mypage
type nameField John Smith
click submitButton True
verifyText name John Smith
Depois de realizados os testes, como já mencionado, devemos fazer o deploy do mesmo no servidor em que está instalado nossa aplicação e assim rodar o Selenium Test Runner no browser, o que nos levaria a tela:
Um passo a passo de como usar o Core pode ser encontrado em http://selenium-core.openqa.org/usage.html, e maiores informações a respeito desse módulo como um todo podem ser obtidas de http://selenium-core.openqa.org/.
Selenium-IDE
Integrada como um plugin para o firefox, onde através dela é possível gravar ações do usuário, editar e deputar os testes de interface. Essa IDE já inclui as funcionalidades do Core.
É uma completa IDE para desenvolvimento de testes, pois além da gravação automática os testes podem ser exportados em diferentes linguagens (Java, HTML, Ruby, C#, PHP etc), modificados manualmente e ainda assim continuarem a ser executados na IDE. Possui uma simples utilização, visto que não existe a necessidade que seu usuário saiba programar, à medida que são executadas as interações do usuário junto à interface estas são gravadas, e se é desejado que uma verificação seja feita basta selecionar uma área da página e marcar o comando desejado.
Em termos de funcionalidade o Selenium IDE serve como uma interface para o Selenium Core de modo a facilitar ainda mais o desenvolvimento dos testes.
É interessante ressaltar a facilidade provida pelo fato da API vir em conjunto com essa IDE de modo que o usuário possa ter uma melhor noção de como usar as ações disponíveis nos testes a serem realizados. Outro ponto de destaque é levar em consideração a velocidade de execução dos testes, controlado através de uma barra na parte superior da IDE. Pudemos perceber que mesmo que a página contenha as informações corretas que estão sendo testadas o uso incorreto dessa velocidade pode levar a conclusões errôneas a respeito da aplicação.
http://selenium-ide.openqa.org/.
Remote Control
É um servidor escrito em java. Ele recebe chamadas http e executa os testes. As chamadas vêm dos testes unitários (com junit, por exemplo). Para criar um teste de funcionalidade com Selenium e JUnit precisamos: i) uma aplicação web; ii)o selenium server; iii)o selenium test client com junit.
O servidor do selenium se comunica diretamente com o browser utilizando AJAX. Logo, pode-ser mandar comandos para o servidor usando simplesmente requisições GET/POST, ou seja, usando qualquer linguagem que permita o uso de requisições HTTP. Desse modo, a distribuição do selenium já fornece uma gama de objetos que podem ser usados nas mais variadas linguagens de programação (Java, .NET, Perl, Python, and Ruby). Para rodar o servidor precisa-se da versão 1.5 do java ou superior. Algumas outras configurações básicas de browser talvez sejam necessárias de acordo com seu SO e podem ser encontradas em http://selenium-rc.openqa.org/tutorial.html.
Podemos enumerar os passos de execução de um teste selenium de forma resumida como sendo mostrado na figura abaixo:
1. O cliente/driver levanta o servidor do selenium.
2. O servidor selenium levanta uma página, ou reusa alguma, com uma URL que carregará a web page do core.
3. O Core irá obter as instruções do cliente/driver através do HTTP Proxy montado dentro do Selenium RC Server.
4. O Core atua na instrução geralmente abrindo uma dada página.
5. O Servidor web é requisitado de modo a fornecer a página procurada e a coloca em sua devida localização, em um dado frame reservado, por exemplo.
Com relação ao uso do servidor podemos interagir com o mesmo através de um modo interativo, no qual vamos digitando linha por linha os comandos a serem executados ou fazer uso de testes, por exemplo, em estilo JUNIT e assim executar um conjunto comandos no servidor.
Uma das grandes novidades inseridas com o RC é que agora os ids dos campos presentes nas páginas têm os mesmos nomes dos atributos da classe de teste, e utilizando reflection também é possível montar os testes dinamicamente. Portanto, agora basta consultar essa classe podemos efetuar testes aleatórios inserindo textos e caracteres especiais em campos numéricos, por exemplo, para ver como o site se comporta.
Vejamos agora alguns detalhes relacionados aos modos de usos.
Modo Interativo
A idéia aqui é digitar um a um os comandos a serem executados no servidor o que acaba por levar os usuários a se familiarizarem melhor com o Selenium RC Server. O servidor pode facilmente ser iniciado com o comando:
1. java -jar selenium-server.jar –interactive
Um exemplo simples de comando a ser usado nesse modo seria o de abrir uma dada página: 1. cmd=getNewBrowserSession&1=*firefox&2=http://www.google.com
Onde aqui estamos requisitando ao servidor que, após teclado enter, abra uma nova sessão no browser de nossa escolha, no caso o firefox, no endereço fornecido. Se tudo funcionar da foma correta uma janela será aberta com a página em questão e alguma mensagem de retorno deverá aparecer no servidor.
O comando acima pode ser adaptado para utlização de diferentes navegadores, no caso utilizamos o Firefox (*firefox), para o Internet Explorer o comando seria *iexplore e para o Opera teríamos *opera da mesma forma para qualquer outro navegador.
Outra ressalva que temos sobre o comando acima é que ele refere-se ao sistema operacional Windows, caso o sistema operacional em uso seja o Linux/Unix ,ou qualquer outro, deve-se indicar o caminho do executável (binário), normalmente “*firefox /usr/lib/firefox/firefox-bin”, no caso do Linux.
Continuando com o exemplo, podemos agora, em sequência, abrir uma janela com a sessão criada e fazer uma pesquisa com a sequência de comandos abaixo:
1. cmd=open&1=http://www.google.com/webhp&sessionId=260113 2. cmd=type&1=q&2=hello world&sessionId=260113
onde btnG é o nome atribuído ao botão da página de pesquisa da Google e o q indica que estamos fazendo uma query.
Poderíamos ainda, por exemplo, ler algum dado da página em questão. Para obtermos o título da página podemos usar o comando:
1. cmd=getTitle&sessionId=260113
Depois de feita uma gama de testes nesse modo devemos encerrar o browser bem como o servidor, ações estas que podem, respectivamente, serem desempenhadas pelos dois comandos a seguir:
1. cmd=testComplete&sessionId=260113 2. quit
Uma explicação mais detalhada dos comandos disponíveis, bem como do uso do modo interativo podem ser encontrados na seção referente ao Selenium Core em
http://www.openqa.org/selenium/ e na página http://selenium-rc.openqa.org/tutorial.html.
Alguns pontos interessantes que merecem destaque com relação ao Selenium RC Server são o fato do mesmo servir como um proxy de modo a permitir que testes sejam executados através de javascripts em páginas que são protegidas pelo política do Same Origin ( maiores detalhes em
http://selenium-rc.openqa.org/tutorial.html, tópico The Same Origin Policy); o suporte para rodar testes em outros browser que não os default do Selenium (IE e firefox) desde que se ajuste os mesmos para usar o Server como proxy (maiores detalhes em http://selenium-rc.openqa.org/tutorial.html, tópico Automatically Launching Other Browsers); a possibilidade de realização de testes em domínios https burlando o esquema de segurança através de certificados da CA CyberVillains, aqui vale o alerta dado pela equipe de desenvolvimento do Selenium de que deixar o browser aceitando esse tipo de certificado comumente pode levar a falhas de segurança em sua navegação na internet, logo deve-se realizar testes para sob tais condições apenas em sites extramamente seguros e lembrando sempre de desabilitar tal autoridade em seguida (maiores detalhes em http://selenium-rc.openqa.org/tutorial.html, tópico Support for HTTPS).
Testes com JUNIT
O primeiro passo a ser seguido na elaboração dos testes JUNIT é você se direcionar a pasta do projeto onde se encontra o selenium-server.jar e lá iniciar o servidor com o comando:
1. java -jar selenium-server.jar
Caso o processo não venha a ser iniciado o teste JUNIT irá terminar com erro e uma mensagem COULD NOT CONTACT SELENIUM SERVER, HAVE YOU STARTED IT? Para matar o processo do servidor ao término de todos os testes basta pressionar as teclas ctrl-c, matando, assim, a execução do processo do mesmo. Vale lembrar que durante a execução dos testes criados no JUNIT podemos visualizar na janela em que iniciamos o servidor as ações que estão sendo tomadas pelo mesmo, como, por exemplo:
1. Command request: getText[//tr[5]/td, ] on session 643603 2. Got result: OK, on session 643603
Isso indica que o mesmo está tentando obter um elemento da quinta linha primeira coluna da tabela na janela em questão, para a sessão previamente iniciada no início do teste. Outro ponto
importante a destacar é que caso esteja-se testando uma aplicação em um servidor local se faz necessário levantar o servidor antes de se colocar os testes para serem executados.
Para a construção de testes podemos extender tanto a classe TestCase (típico do JUNIT), ou caso queiramos ter acesso a uma maior gama de funcionalidades devemos extender a classe SeleneseTestCase e então começar a codificação usando os mais variados métodos da API do Remote Control (http://release.openqa.org/selenium-remote-control/0.9.2/doc/java/). Extendendo SeleneseTestCase temos acesso a funcionalidades como verifyEquals, verifyTrue, verifyFalse, pause, dentre outras.
Levantados os servidores, podemos agora nos remeter a codificação dos testes. Em cada teste a ser criado é necessário estabelecer uma conexão com o servidor, que já deverá estar up para execução dos testes como dito anteriormente:
1. selenium = new DefaultSelenium("localhost", 4444,"*firefox", URL);
2. selenium.start();
Aqui estamos informando o host da nossa aplicação, a porta a ser usada pelo Selenium Server, o browser e a URL de localização da aplicação. Criado esse objeto podemos agora usar o mesmo para desenvolvermos os nossos testes. Por exemplo, caso desejássemos testar o título de uma certa página web faríamos:
1. assertEquals("Billiard League Management System", selenium.getTitle());
Podemos ainda navegar entre frames e assim testar o conteúdo de cada um dos mesmos, como, por exemplo:
1. selenium.selectFrame("mainFrame");
2. assertTrue(selenium.isElementPresent("//p[1]")); 3. assertTrue(selenium.isElementPresent("//img")); 4. assertTrue(selenium.isElementPresent("//p[2]"));
5. assertEquals("Here you have an overview of all the registered leagues in our system. For more information about each league, or player, click on the item of your preference. If
you get amazed by our system, join us.",
selenium.getText("//p[2]")); 6. ...
7. selenium.selectFrame("relative=up"); 8. selenium.selectFrame("leftFrame");
9. assertTrue(selenium.isElementPresent("//tr[2]/td"));
Na maioria dos comandos da interface Selenium devemos passar uma string chamada Element Locator que diz para o Selenium a qual elemento HTML o comando se refere. Existe várias formas de especificar o Element Locator. Na API da interface Selenium é especificada todas as formas. No nosso exemplo estamos utilizando principalmente XPath Expression (para mais detalhes de xpath veja http://www.w3schools.com/xpath/).
Nesse código migramos para o frame central de nossas páginas, e em seguida procuramos os elementos que em nossa codificação criamos com elementos de destaque (com a tag p). Mais abaixo migramos para o frame da esquerda e procuramos agora por um elemento da tabela presente naquele frame na segunda linha primeira coluna (nesse caso podemos usar /td ao invés de precisar especificar /td[1]).
Selenium Grid
Com o uso do Selenium RC típico como vimos acima podemos perceber alguns pontos importantes como:
• Lentidão no controle do browser que pode fazer com que o gargalo do teste seja exatamente o RC
• Lançar mais que 6 browsers começa a afetar a estabilidade do RC
• A escabilidade em termos da quantidade de testes paralelos que podem ser executados acaba barrando o crescimento de situações de teste e deixando o RC muito transparente nos testes.
De modo a resolver esses problemas é que surgiu uma nova ferramenta que é o Selenium Grid (http://selenium-grid.openqa.org/). O Selenium Grid é uma ferramenta que permite a execução de múltiplos testes em paralelo, em várias máquinas e em diferentes SOs. Para rodar esses diversos testes em paralelos podemos muito bem selecionar a quantidade de nós em que os testes serão executados, as versões do SO, etc. A idéia é rodar vários servidores Selenium RC em paralelo formando assim um grid que fica disponível através de uma interface similar a de um único servidor RC que é o Selenium Hub. Assim, vemos que essas várias instâncias do servidor acabam por parecerem transparente a sua aplicação fazendo com que a mesma não altere suas linhas de código típicas de trabalho com o servidor RC anterior para trabalhar no novo ambiente. A idéia básica do funcionamento da ferramenta pode ser percebida na figura abaixo:
É válido lembrar que nessa ferramenta podemos desenvolver testes nas mais variadas linguagens de programação como Ruby, Java, Python, C#, PHP, dentre outras. Para maiores detalhes sobre o funcionamento do Selenium Grid visitar http://selenium-grid.openqa.org/how_it_works.html. Para saber como instalar o Selenium Grid e posteriormente configurá-lo para executar em uma máquina local ou para montar um grid visitar, respectivamente, http://selenium-grid.openqa.org/get_started.html e http://selenium-grid.openqa.org/run_the_demo.html.
Conclusão
Como a interface é uma das partes mais importantes da aplicação, pois esta será a ponte entre o serviço e quem o usará, erros neste módulo são praticamente inaceitáveis e a única forma de descobrir, e da melhor maneira possível, minimizar erros é através da construção de testes de qualidade.
Visto que já é sabido que nos processos de desenvolvimento de software boa parte dos recursos e do pessoal são aplicados na etapa de testes, todo e qualquer artifício que possa ajudar a minimizar essa situação é considerado bem vindo.
Testes de integração, principalmente nos teste de interface, eram quase que totalmente feitos manualmente o que onerava ainda mais a sua construção, por isso Selenium encaixa-se perfeitamente nesse contexto e também por isso tem se popularizado dentre os testadores, principalmente de aplicativos Web.
A ferramenta Selenium é relativamente nova e ainda está em fase de desenvolvimento. Porém, já se encontra funcional para realizar testes de aceitação para interface Web. Um dos grandes problemas é a pouca documentação e a falta de exemplos de como utilizá-la. Por outro lado, ela oferece uma solução interessante para criar testes de interface: o Selenium IDE. Com a IDE pode-se fazer alguns testes básicos com extrema rapidez. Para os mais experientes em programação o uso do Selenium RC permite a codificação de testes em variadas linguagens fazendo uso de uma independência entre o servidor dos testes e o servidor da aplicação, ao contrário da abordagem adotada inicialmente pelo Selenium Core.
Em se tratando a sua facilidade de utilização e a todas as funcionalidades já descritas anteriormente nesse tutorial, Selenium pode ser considerada uma ferramenta altamente recomendável para o desenvolvimento de software.
Bibliografia
1. Selenium Overview, http://selenium.openqa.org/. Acesso em 22 março de 2008. 2. Selenium RC Java Client Diver 0.9.2 API, <
http://release.openqa.org/selenium-remote-control/0.9.2/doc/java/>. Acesso em 22 março 2008.
3. ANDREW GLOVER, Programmatic testing with Selenium and TestNG, < http://www-128.ibm.com/developerworks/java/library/j-cq04037/>. Acesso em 22 março 2008. 4. NICO STEPPAT, Testes de aceitação com o Selenium, <
http://blog.caelum.com.br/2007/02/28/testes-de-aceitacao-com-o-selenium/>. Acesso em 22 março 2008.
5. RODRIGO MAIA, Descobrindo o Selenium, <
http://thinkabouttests.blogspot.com/2008/02/descobrindo-o-selenium.html>. Acesso em 22 março 2008.
