Descobrindo o Selenium

Selenium é a ferramenta mais utilizada para Testes de Integração, ou ao menos a mais popular no meio Java.

Para os nossos exemplos, vamos usar o plugin para o FireFox que facilita muito a tarefa (Uma lista de links importantes esta no final do post, incluindo downloads de plugins e ferramentas).

O Selenium tem o seu próprio testRunner, porém nós vamos utilizar o Selenium-RC para testarmos via código Java, isso possibilita integrar os testes de Selenium com seus Testes Unitários.

Com o plugin do FireFox, iniciamos a usar o Selenium:

Começamos a gravar o processo que queremos testar, no caso um simples login:

Quando completamos o processo que queremos testar, paramos a gravação:

Exportamos o teste feito para código Java:

O código gerado é esse:

0: import com.thoughtworks.selenium.*;
1: import java.util.regex.Pattern;
2:
3: public class login extends SeleneseTestCase {
4:  public void testLogin() throws Exception {
5:   selenium.open("/login.action;" +
6:     "jsessionid=21FC72563" +
7:     "78F1D482601E23C929635A1");
8:   selenium.type("j_password", "1234");
9:   selenium.click("submit");
10:   selenium.waitForPageToLoad("30000");
11:   assertEquals("Área Inacessível",
12:   selenium.getAlert());
13:  }
14: }

O objeto selenium no método acima, nos da informações da página, como um alert, tempo esperado para a página carregar, o titulo, dentre outras coisas.

Para que o teste fique completo, estendemos TestCase, declaramos um atributo selenium do tipo Selenium e criamos o setUp e tearDown:

0: public void setUp() throws Exception {
1:  String url =
2:   "http://www.meuslivroseletronicos.com.br";
3:  selenium = new DefaultSelenium("localhost",
4:    SeleniumServer.getDefaultPort(),
5:    "*firefox", url);
6:  selenium.start();
7: }
8:
9: protected void tearDown() throws Exception {
10:  selenium.stop();
11: }

A classe finalmente deve ficar assim:

0: import junit.framework.TestCase;
1: import org.openqa.selenium.server.SeleniumServer;
2: import com.thoughtworks.selenium.DefaultSelenium;
3: import com.thoughtworks.selenium.Selenium;
4:
5: public class login extends TestCase {
6:  private Selenium selenium;
7:  public void setUp() throws Exception {
8:   String url = "http://www.meuslivroseletronicos" +
9:   ".com.br";
10:   selenium = new DefaultSelenium("localhost",
11:     SeleniumServer.getDefaultPort(), "*firefox",
12:     url);
13:   selenium.start();
14:  }
15:
16:  protected void tearDown() throws Exception {
17:   selenium.stop();
18:  }
19:
20:  public void testLoginLivro() throws Exception {
21:   selenium.open("/login.action;jsessionid=BEF" +
22:   "47FEE6B27A5E7EA20DB20E6F3F4F2");
23:   selenium.type("j_username", "admin");
24:   selenium.type("j_password", "1234");
25:   selenium.click("submit");
26:   selenium.waitForPageToLoad("30000");
27:   assertEquals("Livro Eletronico",
28:     selenium.getTitle());
29:  }
30: }

Estarte o selenium server: java -jar selenium-server.jar que está no diretório selenium-remote-control-0.9.2\selenium-server-0.9.2 do Selenium-RC.

Agora rode como se fosse um teste comum do JUnit.

Links que podem ajudar:

Selenium (http://selenium-ide.openqa.org/)
Download em (http://selenium-core.openqa.org/download.jsp)

Selenium IDE 4 Firefox (http://release.openqa.org/selenium-ide/0.8.7/selenium-ide-0.8.7.xpi)

Selenium 4 Java (http://selenium-rc.openqa.org/java.html)
Download em (http://selenium-rc.openqa.org/download.jsp)

Teste de Integração

O Teste de Integração, ao contrario do Teste Unitário, não se preocupa com o conceito de módulos. Essa modalidade de testes, como seu nome indica, promove o teste de uma funcionalidade sem se preocupar com "de quem é a responsabilidade?".

Pense numa situação de um cadastro, com Teste Unitário você deve criar um teste para as regras de negócios, um outro para os métodos de persistência, porém, no Teste de Integração, você testa somente o método Inserir, ou Update ou Delete e deixa que os módulos si relacionem de verdade, sem Mock Objects, sem nenhum artifício qualquer.

Quando falo "comparando" Testes Unitários com Testes de Integração, não estou dizendo que um é melhor que o outro, até porque eles devem conviver de maneira harmônica, os Testes de Integração verificam um outro escopo, verificam a integração entre os módulos, tanto que, se os testes unitários foram feitos de maneira correta, um teste de integração NUNCA (ao menos, não deverá) encontrará um problema na regra do método implementado, pode encontrar problemas numa injeção de dependências feita pelo Spring ou coisa parecida.

Breve vou escrever sobre o Selenium, uma ferramenta espetacular para fazer Testes de Integração.