Mostrando postagens com marcador selenium. Mostrar todas as postagens
Mostrando postagens com marcador selenium. Mostrar todas as postagens

quinta-feira, 29 de agosto de 2013

Pare de criar scripts de teste e comece a pensar

Sim, PARE!!!
Vamos contextualizar o título.

Conceituação

Hoje o mercado pede automação de teste e as pessoas, obviamente vão em busca do que o mercado pede. Não todas obviamente, mas uma grande parte. Com a ascensão da agilidade na entrega dos softwares hoje em dia, onde muitos tomam como base um produto que é potencialmente entregável em uma variação/período de tempo de 2 a 4 semanas (obviamente não é a regra mas muitas equipes trabalham com essa variação).

Ai comece a pensar o seguinte: como eu vou garantir que, a cada variação destas (2 a duas semanas ou 4 a 4 semanas), para um mesmo produto, eu conseguirei garantir a qualidade do que está sendo desenvolvido?

Vamos incluir aqui a automação de teste em todos os níveis, segundo a pirâmide de automação de teste.
Olhando esta variação notamos que há uma grande vantagem em automatizar tudo o que pudermos ao invés de executar testes manualmente, certo? Obviamente sabemos que os testes automatizados não substituem os testes manuais por completo, mas essa é uma linha de raciocínio que não é falsa.

Logo, precisamos nesta variação, automatizar o que for factível para que no final:
  • o produto potencialmente entregável funciona como esperado (aspecto implícito de qualidade)
  • que, durante as próximas entregas de novas funcionalidades ou alteração de funcionalidades existentes, o tempo não seja desperdiçado na execução do teste manual e que o(s) script(s) de teste executem, onde ganhamos um feedback continuo dos testes

 

Senso comum

Ótimo Elias, você me convenceu, automatizar é a solução... Então vamos logo automatizar!

O que o mercado faz

O termo "mercado" aqui diz respeito ao profissional, seja ele desenvolvedor, tester ou qualquer outro papel, que vai automatizar algo. Também é a minha visão e opinião sobre o mercado.
Dado a agilidade na entrega do software o que o mercado faz é entender a funcionalidade e começar a automatizar nos períodos pertinentes.
Só que existem problemas quando "baixamos a cabeça" e começamos a automatizar...
  • Nem sempre a funcionalidade que será automatizada é realmente entendida pelo automatizador ou mesmo pela equipe
  • A automação, as vezes, é feita sem um conhecimento geral sobre programação com a utilização de ferramentas record & play
  • A execução da automação é feita um a um. Ou seja, existem diversos scripts de teste, mas o profissional abre e executa cada um
  • Depois de um tempo, o próprio profissional não sabe o que o script faz
  • Mesmo com uma série de scripts prontos, um novo bug sempre é encontrado pelo cliente

O mercado em si também trabalha muitas vezes de uma forma que não há ganhos em automatizar. Ex: um profissional de teste recebe, para poder automatizar, uma série de documento de requisitos, regras de negócio e casos de uso para automatizá-los. Com isso o foco da automação fica apenas na visão de um único requisito/caso de uso/regra. Isso pode ser extremamente ruim porque a automação dificilmente vai mostrar valor no conjunto da obra.

Não vou comentar aqui sobre testar/automatizar quando não se tem quase documentação porque, neste caso e na minha visão, existe uma grande chance de você conseguir testar e automatizar certo... mas isso é outro post...


Para de criar scripts e comece a pensar!

OK, temos um curto período de tempo se falarmos em agilidade (lembra das 2 a 4 semanas mágicas que muitos adotam), então começar a automatizar o mais rápido possível é a solução!

Sim, pode ser, mas pare de criar scripts e comece a pensar!

A grande maioria das pessoas que me procuram pedindo ajuda em automação, principalmente automação funcional/UAT é que os scripts param de funcionar e estes não conseguem mais "fazer com que o script passe".
E sabe porque isso acontece? Porque estas pessoas simplesmente "baixaram a cabeça" e começaram a automatizar.
Também há outro problema que é a falta de conhecimento na ferramenta em que se está utilizando.


Explicando no lado técnico da coisa

Começando do básico, e um dos exercícios que eu faço muito com meus alunos no meu Treinamento de Selenium/WebDriver, é primeiro olhar como a página funciona num olhar de usuário, não de testador (embora o testador tenha um olhar de usuário, no momento em que ele vai automatizar algo ele olha como olhar de tester).
Vamos pegar um exemplo, e você não vai perder mais 5 min neste post :)

O teste é simples:
  1. Acesse a página http://eliasnogueira.com/arquivos_blog/geral/collapse/
  2. Clique sobre a 'div preta' "Minhas Páginas"
  3. Clique sobre o link "Treinamento Agile Testing"

Simples não? Porque então não automatizar logo???
Bom, antes de continuar lendo o post tente automatizar na sua ferramenta de automação web preferida.


Resultado da automação sem pensar no comportamento

Se você automatizar exatamente os passos o teu script falhará! Sim, ele vai falhar!
Provavelmente ele vai falhar quando você executa o terceiro passo, que é clicar no link "Treinamento Agile Testing"

Abaixo vou colocar o trecho de código automatizando com WebDriver + Java, ignorando os devidos imports.

WebDriver driver = new FirefoxDriver();
driver.get("http://eliasnogueira.com/arquivos_blog/geral/collapse/");
driver.findElement(By.id("section1")).click();
driver.findElement(By.linkText("Treinamento Agile Testing")).click();

 

Vamos pensar no comportamento da página

Ao invés de automatizar com um olhar de desenvolvedor ou testador, vamos olhar como um usuário e mais: vamos descrever o comportamento da página.
O comportamento que eu vejo é o seguinte:
  •  Eu acesso a página em questão e ele carrega
  •  Me mostra algumas informações
  •  Eu clico em "Minhas Páginas"
  •  Um efeito é aplicado apresentando três links
  •  Eu espero o efeito terminar
  •  Eu clico no link "Treinamento Agile Testing"

Agora comparem a descrição do comportamento com os passos que eu descrevi anteriormente. Qual a diferença?
Descrevendo o comportamento da página eu coloquei uma coisa muito importante: que eu espero o efeito de clicar em "Minhas Páginas" acabar para que eu possa clicar no link "Treinamento Agile Testing"

O que faltou então: a espera!
Simples não, mas tem elementos simples que não nos damos conta que fazem nosso script falhar "sem razão".
Adicionando uma espera o script, funcional, fica assim:

WebDriver driver = new FirefoxDriver();
driver.get("http://eliasnogueira.com/arquivos_blog/geral/collapse/");
driver.findElement(By.id("section1")).click();
       
By byAgileLink = By.linkText("Treinamento Agile Testing");
WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.elementToBeClickable(byAgileLink));
       
driver.findElement(byAgileLink).click();  


Porque isso ocorre?

O primeiro problema é a afobação, sim!!!!
Logo quando vemos algo fácil (ou mesmo difícil), por pressão de tempo, por baixa complexidade ou por diversos outros fatores começamos logo a escrever scripts de teste automatizado "sem pensar".


O problema do lado da arquitetura

Poucos testers que eu conheço, sim poucos mesmo, pensam em arquitetura para a automação de teste!
O que eu quero dizer com arquitetura é você fazer as seguintes perguntas:
  •  como eu executarei todos os scripts?
  •  como eu saberei o resultado da execução?
  •  como qualquer pessoa terá acesso aos scripts e a executá-los?
  •  como eu irei escalar os scripts? (quando novas funcionalidades entrarem)
  •  como eu farei a manutenção dos scripts?
  •  como eu irei informar o ambiente que os scripts serão executados?

Existem muitas outras perguntas que podemos fazer, mas isso já te dá uma boa noção do que é pensar em arquitetura para a automação de teste.

Então não é apenas "baixar a cabeça" e criar scripts. Imagine que o software a cada variação/período, tenha mais e mais funcionalidades. Como você vai responder as perguntas acima?
Se você não pensar nestes aspectos vai ser muito, mas muito mais vantajoso executar os testes manualmente porque você perderá muito tempo tentando arrumar/consertar os scripts.
É neste ponto que a maioria dos profissionais falha na nossa área: vendemos automação como sendo algo legal, mas depois nossos pares/colegas/gerentes veem isso como uma coisa difícil de manter e complicada, caindo em descrédito e não enxergando benefícios.
Tudo isso porque não pensamos antes de fazer!!!


Dica

Sempre, sempre que você for automatizar qualquer funcionalidade que seja, escreva em um bloco de notas ou pense quais são os reais passos que você está executando como um usuário. Depois disso, se você ainda não estiver muito familiarizado com a ferramenta que estás utilizando, tenta substituir cada ponto anotado por comandos. Obviamente terão pontos que não serão comandos, mas isso fará você pensar em tudo o que ocorreu na página e cobrir isso na criação do script.

Também conheça muito bem da ferramenta que você está utilizando e evite ao máximo record & play.
Uma ferramenta com record & play, muito provavelmente, não terá pontos de sincronização (a espera que fizemos) e você vai esquecer rapidinho de que existe uma sincronização a ser feita.


Conclusão

Testar coisa é uma tarefa investigativa, então tudo começa com um curiosidade e estudo do comportamento das coisas.
Todo o teste deve ser sempre baseado em uma hipótese, e quando você cria uma hipótese qual a primeira coisa que fazemos? Estudamos as possibilidades, analisamos comportamentos e depois aplicamos o teste para validar que a hipótese é ou não é verdadeira.

O nosso senso de urgência e conhecimento sempre vai nos dizer para não perder tempo pensando, afinal eu já tenho conhecimento e experiência bastante para fazer isso. Mas a prática real é bem diferente. Estudar comportamentos e pensar antes de qualquer coisa, não só para criar scripts de teste, nos dá uma visão muito melhor do que fazer.


Leitura recomendada: Tester, para de testar!


quarta-feira, 10 de abril de 2013

Treinamento Selenium 01 e 02 de Junho

No mês de Junho: Automação de Testes Funcionais com Selenium à distância.

Data
01 e 02 de Junho

Horário
Dia 01, sábado - 09:00 às 18:00
Dia 02, domingo – 09:00 às 18:00

Investimento
550,00 para pagamentos até data 10 de Maio
650,00 após esta data
Forma de pagamento: cartão de crédito em até 12x, boleto ou transferência bancária

Local
Treinamento a distância. Será realizado no seu computador via Internet utilizando ferramenta de web-conferência. 

Infra-Estrutura
Sistema Operacional: Windows ou MacOS (O GotoMeetting não suporta Linux)
Plugin para acesso ao GoToMeeting através do navegador (no dia do treinamento o participante receberá um link para acesso a sala de conferência)

Instrutor
Elias Nogueira
Possui MBA em Teste de Software e a certificação internacional de teste de software CSTE - Certified Software Tester, oferecida pela QAI Brasil. Atualmente é arquiteto de testes na InMetrics, consultor de automação de testes e instrutor pela Qualister e pela Iterasys. Trabalhou em projetos de engenharia de teste de qualidade de dados (Data Mining, Data Cleasing, Data Profiling, Noisy text analysis) e Georeferenciamento (Marketing de Precisão) e atualmente trabalha em projetos de automação de teste de software na InMetrics em diversos segmentos (bancário, varejo e cartões). Tem grande foco e conhecimento em ferramentas open source de automação de teste. É colaborador freqüente das listas de discussões sobre Teste de Software e posta suas experiências e dicas no blog Sem Bugs (http://sembugs.blogspot.com).

Carga Horária
16 horas

Inclui
Certificado em formato digital e acesso ao material em formato digital

Tópicos Abordados
Selenium IDE
   - Record and Play
   - JavaScript
   - Alertas e Confirmações
   - Popup’s
   - Elementos HTML
   - Expressões Regulares
   - Ajax Loading
   - Ajax AutoComplete
   - Ajax Carrinho de Compras
   - Combo Cidade/Estado

Selenium RC
   - Executando scripts criados no Selenium IDE em diversos browsers com Selenium RC

WebDriver
   - Interagindo com elemento HTML com Webdriver
   - Esperas por requisições assíncronas (Ajax)
   - Webdriver + JUnit
   - Data Driven com Webdriver
   - Automatizando para diversos browsers usando o Webdriver
Informações
48 3285-5615

segunda-feira, 25 de fevereiro de 2013

Como aprender sobre Selenium (de forma gratuita ou paga)

Olá pessoal!
Recebo quase todos os dias e-mails de profissionais da área perguntando como eles podem aprender sobre Selenium e onde podem encontrar materiais.

Este post se destina a isso: como aprender Selenium de uma forma "gratuita" ou não!
Quando eu falo Selenium, na verdade estou falando de WebDriver (apesar de existirem pessoas que querem aprender sobre o Selenium IDE e vou citar isso, o foco maior é em WebDriver)

Aprendendo Selenium de forma gratuita
Atualmente, até onde eu sei, não existe nenhum treinamento gratuito sobre Selenium.
O aprendizado gratuito pode se dar através de:
  • Leitura da documentação
  • Leitura e entendimento da API
  • Prática
  • Apresentações
  • Desafios Selenium

Leitura da documentação
Existem duas documentações padrão do Selenium:
  • Através do site http://seleniumhq.org: neste site você pode acessar a 'aba' Documentation e ler realmente a documentação. Há muita coisa boa lá e realmente te dá uma boa base inicial


O ideal é você ler todos os documentos contidos no Wiki, mas estes itens acima já irão lhe dar um overview sobre o WebDriver


Leitura e entendimento da API
Com o WebDriver é inevitável: temos que programar/desenvolver nossos testes utilizando alguma linguagem de programação!
Logo é um pré-requisito que você conheça, pelo menos, o básico da liguagem de programação de sua escolha e que também saiba como ler a API (documentação das ferramentas/plugins/frameoworks) implementados em uma determinada linguagem.

Podemos visualizar abaixo a lista das linguagens de programação formalmente suportadas com WebDriver e o link de cada API (documentação):

Prática!
Para aprendermos qualquer ferramenta não tem jeito: temos que praticar!
Logo a prática é um elemento fundamental do nosso aprendizado.
Você pode praticar em diversos sites web, mas aqui vai minha recomendação:
  • Começe a praticar em sites/aplicações simples
  • NUNCA tente praticar automatizando o login do Gmail, Yahoo! e outros...
  • Utilizar CMS ou lojas virtuais open source para praticar é uam boa. Você pode praticar num Joomla, Prestashop, por exemplo

Apresentações
Sempre é bom dar uma "Googleada" para encontrar apresentações ou links.
Eu recomendo dar uma olhada no SlideShare, site que contém uma gama de apresentações publicadas e diversas sobre Selenium.

Desafios Selenium
Foi uma iniciativa que eu criei em 2011 lançando um problema real, onde o mesmo deve ser automatizado com Selenium IDE.
Os desafios possuem a resolução explicada em vídeo, o que facilita o entendimento.
Por enquanto eu tenho somente 5 desafios e todos com respostas para o Selenium IDE, porém logo em breve voltarei a postar mais desafios em ambos os formatos: Selenium IDE e WebDriver!


Aprendendo Selenium de forma paga
Obviamente sempre temos alternativas pagas! Geralmente esta alternativa foca mais no que cada um precisa aprender e dependendo da forma que você escolher, um curso por exemplo, você conseguirá (ou não, pois depende de você) tirar um maior proveito e resolver problemas e dúvidas que você possa ter. O aprendizado pago pode ser:
  • Através de Cursos
  • Através de Livros

Atavés de Cursos
Existem dois treinamentos sobre WebDriver (um que cobre Selenium IDE que eu conheço), que serão listados abaixo:

Treinamento de Selenium (IDE, RC, WebDriver) do Elias Nogueira (eu)
Há algum tempo eu dou treinamento sobre Selenium.
Os treinamentos são no formato EAD síncrono, traduzindo, são treinamentos via videoconferência ao vivo. O aluno acessa um link onde vê a tela do instrutor e segue suas instruções.

Atualmente o curso é dividido em 4 módulos:
  • Selenium IDE Básico
  • Selenium IDE Avançado
  • WebDriver Básico
  • WebDriver Integrações
Todos os exercícios cobrem as principais dúvidas e interações que faremos na "vida real". Os exercicios resolvidos no Selenium IDE e WebDriver são disponibilizados, bem como uma apostila e certificado de participação.

Para saber mais sobre o treinamento acesse: http://sembugs.blogspot.com.br/p/curso-de-selenium.html


Treinamento de WebDriver (em inglês) do Alan Richardson (EvilTester)
Um cara chamado Alan Richardson, mais conhecido como EvilTester (seu blog) criou um treinamento sobre WebDriver no site Udemy.
O treinamento são video-aulas em inglês que mostram como trabalhar com o WebDriver em diversos pontos:
  • Navegação
  • Suporte dos testes com JUnit
  • Locators
  • Interações
  • RemoteWebdriver
  • CI

Link do treinamento: https://www.udemy.com/selenium-2-webdriver-basics-with-java/


Através de Livros

Existem livros muito bacanas sobre Selenium, mas infelizmente para alguns estes livros são em inglês (pra quem não consegue ler livros em inglês ainda fica o incentivo para aprender!)



Livro: Selenium Simplified

Este livro é do mesmo autor do curso do Udemy que eu coloquei acima: Alan Richardson. Este livro sobre a utilização do Selenium RC/WebDriver utilizando Java e JUnit.
É muito parecido com o próprio treinamento que o autor tem, mas os itens cobertos no livro possuem mais detalhes.

Link da página do livro: http://www.compendiumdev.co.uk/selenium/





Livro: Selenium Testing Tools Cookbook

Este livro mostra, além do básico de programação com WebDriver, problemas reais e como resolvê-los.
Também apresenta como fazer integrações de ferramentas de BDD e ATDD, como executar testes no Selenium Grid, como capturar evidências e como executar testes em browsers de dispositivos móveis (Android e iOS)

Link da página do livro: http://www.packtpub.com/recipes-to-master-selenium-2-testing-tools-cookbook/book



Livro: Selenium 2 Testing Tools

Este livro é de autoria de um dos commiters do Selenium: David Burns. Neste livro o autor aborda todos os conceitos  básicos do WebDriver unidos a alguns Design Patters para ajudar o leitor a desenvolver melhor usando o WebDriver.

Link da página do livro: http://www.packtpub.com/selenium-2-testing-tools-beginners-guide/book






Espero que este post seja de grande ajuda aqueles que desejam iniciar o aprendizado do Selenium.
Qualquer dúvida ou sugestões de links, cursos e livros deixem um comentário neste post :-)

Abraços!


terça-feira, 29 de janeiro de 2013

Treinamento Selenium a Distancia em Fevereiro 2013

Olá pessoal!
Na data abaixo estarei dando um treinamento de Selenium a distância que vai abordar um pouco de cada ferramenta com abordagem totalmente pratica!
 
Data
23 e 24 de Fevereiro

Horário
Dia 23, sábado - 09:00 às 18:00
Dia 24, domingo – 09:00 às 18:00

Investimento
550,00 para pagamentos até data 15 de Fevereiro
650,00 após esta data
Forma de pagamento: cartão de crédito em até 12x, boleto ou transferência bancária

Local
Treinamento a distância. Será realizado no seu computador via Internet utilizando ferramenta de web-conferência. 

Infra-estrutura
Sistema Operacional: Windows ou MacOS (O GotoMeetting não suporta Linux)
Plugin para acesso ao GoToMeeting através do navegador (no dia do treinamento o participante receberá um link para acesso a sala de conferência)

Instrutor
Eu! :-)


Carga Horária
16 horas

Incui
Certificado em formato digital e acesso ao material em formato digital

Topicos
Selenium IDE
   - Record and Play
   - JavaScript
   - Alertas e Confirmações
   - Popup’s
   - Elementos HTML
   - Expressões Regulares
   - Ajax Loading
   - Ajax AutoComplete
   - Ajax Carrinho de Compras
   - Combo Cidade/Estado

Selenium RC
   - Executando scripts criados no Selenium IDE em diversos browsers com Selenium RC

WebDriver
   - Interagindo com elemento HTML com Webdriver
   - Esperas por requisições assíncronas (Ajax)
   - Webdriver + JUnit
   - Data Driven com Webdriver
   - Automatizando para diversos browsers usando o Webdriver
 
Informações
48 3285-5615

Link na Qualister

quinta-feira, 3 de maio de 2012

Como obter conhecimento técnico em Teste de Software (de forma gratuita)

Olá pessoal!
O intuito deste post é mostrar diversas fontes de conhecimento na internet para aqueles testadores que querem se tornar mais técnicos e não sabem por onde começar.
Nem sempre é preciso correr para cursos pagos (que também é uma boa pedida).

Aqui vou listar diversos links sobre ferramentas, tecnologias e metodologias para estudo.
Um único pont bom (ou ruim para alguns) é que a maioria do material é em inglês (nada que um google translator não resolva se você não souber inglês)

Ponto importante: este post será um post "vivo". Portanto a sugestões de todos vocês sobre cursos e conteudos gratuitos de boa qualidade será ótimo para contribuir com a disseminação de conhecimento.


Diversos

W3Schools
Possui diversos tutoriais para tecnologia web gratuitos.

Fundação Bradesco
A Fundação Bradesco possui diversos cursos de informática, muito deles que podemos aproveitar para o nosos aprendizado.
Tente focar nos cursos dos itens Banco de Dados e Desenvolvimento de Aplicativos. Dento deste último eu não recomendo os seguintes cursos por não ser o foco deste aprendizado: Expression Blend, Ilustração & Design Gráfico para Web e Silverlight.

Qualifico Ensino e Tecnologia
Não estou fazendo propaganda deles, mas eles possuem um mini curso gratuito de Teste Exploratório que vale a pena ser assistido.

SQL Básico

Xpath

Ferramentas de Automação
Lista de ferramentas open source para automação de teste. Leia-se open source por ferramentas de código e conteudo (documentação) aberto.

Selenium

AutoIT

Lógica de Programação

Não fazendo propaganda, mas aqui você encontra muitos cursos básicos por um baixo custo


Linguagem de Programação

Java

Ruby

Colaboradores deste post

Leonardo Galani: do blog keeptesting.com.br sobre xpath
Fernanda Lessa: mandou sua colaboração através da lista guts-rs@googlegroups.com sobre a Fundação Bradesco

segunda-feira, 1 de agosto de 2011

Automação de Testes Funcionais com Selenium Avançado a distância (em Agosto)

Olá pessoal!
Agora em agosto eu vou dar um treinamento de Selenium pela Qualister!
Abaixo segue a descrição do treinamento, que é oferecido no formato EAD (Ensiso a Distância)

OBJETIVO
  • Automatizar testes com o Selenium RC com a linguagem Java com o apoio dos frameworks de teste unitário JUnit e TestNG
  • Entender todos os conceitos do Selenium 2  (WebDriver)
  • Converter e customizar scripts gerados no Selenium IDE
  • Automatizar scripts do Selenium IDE com a técnica de Data Driven
  • Integrar os scripts criados no Selenium RC com um Hudson/Jenkins (Integração Contínua).
  • Entender como integrar o Selenium com as ferramentas de teste Testlink e Mantis

DATA
26 e 27 de Agosto (sexta e sábado)

HORÁRIO
Dia 26, sexta-feira - 19h00 as 23h00
Dia 27, sábado - 09h00 às 12h00 - 13hh00 às 18h00

CARGA HORÁRIA
12 horas

LOCAL
Treinamento a distância. Será realizado no seu computador via Internet utilizando ferramenta de web-conferência.

CONHECIMENTOS DESEJÁVEIS
Conhecimentos básicos sobre teste de software e programação
Conhecimentos básicos do Selenium IDE

MINISTRANTE
Elias Nogueira: Possui MBA em Teste de Software e a certificação internacional de teste de software CSTE - Certified Software Tester, oferecida pela QAI Brasil. Atualmente é Arquiteto de Testes, Consultor de Automação de testes e Instrutor pela Qualister. Trabalhou em projetos de engenharia de teste de qualidade de dados (Data Mining, Data Cleasing, Data Profiling, Noisy text analysis) e Georeferenciamento (Marketing de Precisão) e em segmentos bancários, de varejo e cartões. Tem grande foco e conhecimento em ferramentas open source de automação de teste. É colaborador freqüente das listas de discussões sobre Teste de Software e posta suas experiências e dicas no blog Sem Bugs (http://sembugs.blogspot.com).

INCLUI
Certificado impresso e material em formato digital

INVESTIMENTO
500,00 para pagamentos até dia 12 de agosto (este valor é para uma inscrição)
650,00 após esta data (este valor é para uma inscrição)
Desconto especial para grupos (entre em contato conosco para maiores informações)

Forma de pagamento: cartão de crédito em até 12x, boleto ou transferência bancária

TÓPICOS ABORDADOS
  • Selenium RC com linguagem Java
  • Automação com JUnit
  • Automação com TestNG
  • Selenium 2 (WebDriver)
    • Browser Drivers
    • Waits
    • Localização de Elementos
    • Como atualizar um script do Selenium 1 para Selenium 2
  • Selenium IDE e Data Driven
    • Plugin Flow Control
    • Plugin Data Driven
    • Plugin Command4IDE
  • Integração com Integração Contínua: Hudson/Jenkins
  • Integração do Selenium RC com Testlink e Mantis

INFORMAÇÕES
treinamento@qualister.com.br
48 3285-5615 / 9645-5506

domingo, 24 de abril de 2011

Desafio Selenium: Auto Preenchimento de Campos

Olá pessoal!
Neste desafio será necessário automatizar um o resultado de um auto-preenchimento.

DICAS:
A única dica é a utilização de um comando específico para poder validar o resultado esperado.

SUGESTÃO: Passos a serem executados no script

Passos 1
  • Informe o seguinte CEP no campo CEP: 01310200
  • Os dados de Logradouro, Bairro, Cidadee Estado serão preenchidos automaticamente
  • Preencha o campo Número com o valor: 1578
  • Preencha o campo Complemento com o valor: MASP
  • Para cada campo em tela, valide o seu conteudo com um assertValue
  • Reexecute o script

Passos 2
Conseguiu fazer o script funcionar? Agora incremente com mais estes dois passos:
  • Clique no botão Limpar
  • Garanta que todos os campos na tela estão sem preenchimento

Acesse a página do desafio:
http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/index.html

Resultado
Vocês podem ver  vídeo explicativo abaixo e tmbém ver o resultados dos colaboradores e o script parão em: http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/resultados/4desafio/resposta.php

terça-feira, 29 de março de 2011

Desafio Selenium: Carrinho de Compras

Olá pessoal!
Neste desafio será necessário automatizar um carrinho de compras, onde as compras serão feitas arrastando os itens até o carrinho.
Para que isso seja possível segue algumas dicas e os passos necessários para a automação deste desafio.

DICAS:
  1. Procupre pelos comandos de drag and drop no Selenium e verifique o que cada um faz
  2. Use o Firebug para analisar o nome dos elementos
  3. Quando for utilizar o comando de drag and drop o primeiro parâmetro é o elemento que representa o produto do carrinho e o segundo é o elemento que represente o próprio carrinho.

Se você conseguir colocar pelo menos um dos itens por automação ja está ótimo! Se conseguir isso eu sugiro você seguir os passos da sugestão:

SUGESTÃO: Passos a serem executados no script
  1. Arraste os seguintes produtos para o Carrinho de Compas:
    • iPhone
    • iPod Shuffle
    • Apple TV
  2. Valide o valor de cada um na lista e o valor total
  3. Clique no botão 'Checkout'
  4. Valide cada nome de produto e o valor total
Acesse a página do desafio:
http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/index.html

Resultado
Vocês podem ver  vídeo explicativo abaixo e tmbém ver o resultados dos colaboradores e o script parão em: http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/resultados/3desafio/resposta.php

segunda-feira, 21 de março de 2011

Desafio Selenium: Edição de Campos

Olá Pessoal!
Agora segue mais um Desafio Selenium, que agora consiste na edição de três dados básicos: nome, e-mail e telefone.
O intuito deste desafio não é a validação de campos e sim a automação da edição destes campos com o Selenium IDE, onde esta edição não atualiza a página (edição inline)...

Logo o que precisa ser feito é somente um clique sobre o item (nome, e-mail ou telefone), a alteração da informação e a persistência dela (clicar no botão 'Salvar'). Após isso é necessário a validação das informações adicionadas, para garantir que elas estarão lá!

Essa é bem fácil e, basicamente, conseguimos resolver com apenas um comando!
E esse comando não pode ser o pause!

http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/index.html

Qualquer dúvida ou sugestões de desafios não deixe de comentar!

Solução!

Bem pessoal, a solução deste desafio já se encontra disponível!
Se você está vendo este post somente agora, tente fazer o desafio sem ver a resposta e o vídeo explicativo!

O link para a página do principal dos desafios é: http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/index.html

Vídeo explicativo


Abraços!

terça-feira, 15 de março de 2011

Desafio Selenium: Automatizando Soma Aleatoria

Olá Pessoal!
Estava entrando em um site que tinha um captcha simples: a soma de dois números inteiros.
Eu gostei, pois existem captchas que nem o Perna Longa iria enxergar as letras....

O que eu fiz? Fui logo vendo uma maneira de automatizar este simples captcha, e não é que funcionou?
Dai resolvi criar uma página com o "Desafio Selenium" (que nem é tão desafio assim!) :P

O desafio consiste em conseguir automatizar a página que eu criei de um 'captcha' que, quando a soma dos dois números for submetida correramente apresenta o texto 'correto' e quando não estiver correto apresenta 'errado'.
Claro que o script será criado com o resultado final de 'correto'.

Então, tentem criar um script no Selenium IDE para automatizar. A página dá umas dicas!

http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/1desafio/

Solução!
Bem pessoal, a solução deste desafio já se encontra disponível!
Se você está vendo este post somente agora, tente fazer o desafio sem ver a resposta e o vídeo explicativo!

O link para a página do principal dos desafios é: http://www.eliasnogueira.com/arquivos_blog/selenium/desafio/

Vídeo explicativo


Abraços!

sexta-feira, 28 de janeiro de 2011

Data Driven com Selenium IDE? Sim, é possível!!!

Selenium IDE com Data Driven? Sim, isto agora é possível!

Observações iniciais
Eu sempre tive uma postura de um profisisonal, quando em aprendizado do Selenium, aprender o IDE a fins educativos e de primeiro passo da automação (record & play), de usar e propor aos profissionais e alunos que me procuram a usar o Selenium RC para fazer testes que exigem bem mais do que o IDE: loops, controles, parametrização de dados, etc...
Mas desta vez resolvi postar sobre como fazer com que o Selenium IDE execute scrips Data Driven


ATENÇÃO: Este post é uma alteração do post original da SauceLabs [1] que você pode acessar no link abaixo:
http://saucelabs.com/blog/index.php/2011/01/selenium-resources-for-newbs-data-driven-testing-with-ide-xml/


Ainda mantenho fortemente a minha postura: usem o Selenium RC com qualquer linguagem para usar todo o poder que essa ferramenta pode te dar. Um dos principais motivos de escrever este post é de:
  • Eu gostar destas coisas novas e ficar brincando com os scripts
  • De ajudar os nossos amigos profissionais que ainda não sabem falar inglês e não poderiam entender o post origianl (e que devem levar um puxão de orelha por isso)
  • Para poder ajudar aqueles que estão aprendendo o Selenium IDE que, mesmo que este post te ajude, não vai poder fugir da programação para fazer coisas mais poderosas com a ferramenta
      
    [1] Pra quem não sabe o criador da SouceLabs, que presta serviços de teste com Selenium nas nuvens, é um dos criadores do Selenium.

    Ahh, e pra quem não sabe o que é Data Driven, é o "poder" de dar ao script a independência de dados através de parâmetros inseridos ao invés dos dados. Se você ainda não sabe o que é isso, Google!


    O que você vai precisar!
    Basicamente de um plugin e duas "user-extensions" do para o Selenium IDE.
    Primeiro siga estes passos:
    1. Instale o plugin de Flow Control. Necessita de reinicio do Firefox
    2. Baixe a user-extension includeCommand4IDE na versão 1.1
    3. Baixe a user-extension datadriven.js, que está na versão 0.2
    Clique nos links de cada item para baixá-lo!
    Instalou o Flow Control e baixou as duas user-extensions? Faça o seguinte:
    1. Descompacte os arquivos zip das respectivas user-extensions num diretório de sua escolha
    2. Adicione as duas user-extensions no Selenium IDE via menu Options/Options... clicando no botão browser para o item Selenium Core extensions (user-extension.js) (vide Possíveis Erros #1)
    3. Reinicie o Selenium IDE
    Deu tudo certo? Maravilha!!! Vamos para os próximos passos!!!


    Criar o arquivo XML de Massa de Dados!
    Sim, para que seja possível fazer com que o script Selenese (script HTML do Selenium) esteja preparado para o Data Driven é necessário criar um arquivo XML que vai conter os dados que tu vais utilizar!

    Uma coisa muito importante é primeiro entender o arquivo XML!

    Entendendo o arquivo XML
    Abaixo está um exemplo do arquivo XML que estou usando:










    A linha 1 possui a tag testdata. É ela que identifica que o arquivo XML é a tua massa de dados.

    As linhas 2, 3 , 4 e 5 possuem a tag test. Cada tag test é um indício de massa de dados que tu vais utilizar no script. Dentro desta tag existem atributos. No exemplo acima os atributos são nome e sobrenome. Estes atributos serão os parâmetros do teu script do Selenium, que irão no formato ${nomeAtributo}.
    Neste caso eu tenho que colocar no meu script os parâmetros ${nome} e ${sobrenome} sem precisar cria-los anteriormente no script.

    A linha 6 fecha a tag do testdata

    Cada atributo tem um valor e é este valor que vai ser substituido pelo parâmetro no script. Lindo né?

    Tu podes criar diversos test um para cada iteração do script que tu necessitar.

    Agora aconselho fortemente ler os itens #2, #3 e #4 do "Possiveis Erros"



    Script!! (êeeeee)
    Agora veremos o script final sobre o exemplo e todos os comandos necessários para que ele funcione!

    loadTestDatafile:///C:/selenium_datadriven/massa_dados.xml
    open/arquivos_blog/selenium/datadriven/
    while!testdata.EOF()
    nextTestData
    typenomePessoa${nome}
    typesobrenomePessoa${sobrenome}
    clickAndWaitsend
    assertTextPresentOlá, ${nome} ${sobrenome}
    clickAndWaitlink=Voltar
    endWhile

    Na linha 1 da tabela temos o comando que fará o carregamento da massa de dados com o comando loadTestData. Este comando é parte da user-extension datadriven.js.
    Você obrigatoriamente deve iniciar o valor deste comando com 'file:///' (sem as aspas simples) seguido pelo caminho do arquivo XML (como no exemplo)

    Na linha 2 da tabela temos o velho conhecido comando open para a minha página de exemplo deste post

    Na linha 3 da tabela temos o comando while, da user-extension FlowControl, que é responsável de fazer um loop no script. O valor deste comando é !testData.EOF() que traduzindo quer dizer: "enquanto o testData não terminar, ou seja, existam as tags test, execute". Ele que é responsável por controlar o número de execuções a partir das tags test existentes.

    Na linha 4 da tabela existe o comando nextTestData que pertence a user-extension datadriven.js. É ela que validará que existam dados na massa de dados (arquivos XML para continuar executando o script)

    Naz linhas 5, 6, 7, 8 e 9 existem os comandos básicos do Selenium para a interação com o exemplo. Aqui tu precisas prestar muita atenção: ao invés de manter os valores fixos no script eu os substitui pelos parâmetro ${nome} e ${sobrenome}, que são os nomes dos atributos da tag test do XML da massa de dados, ententeu? É só colocar o mesmo nome e, acredite, ele preencherá com o valor.

    Na linha 10 da tabela há a finalização do loop pelo comando endWhile que pertence a user-extension FlowControl.


    Agora é só correr para o abraço!!!
    Pronto, tudo está pronto para execução com sucesso!!!
    Tu podes baixar o este exemplo por este link e testar ai!

    Se tu executares o exemplo que tu acabou de baixar, lembre-se de colocar na Base URL o endereço http://eliasnogueira.com

    Agora vamos falar sobre o exemplo:

    Exemplo utilizado!
    O exemplo é bem simples: consiste em um formulário de submissão de dados contendo o Nome e Sobrenome de uma pessoa. Após a submissão dos dados somos redirecionados para uma tela com a seguinte mensagem na página "Olá Fulano de Tal", onde Fulano é o nome e de Tal é o sobrenome inserido!

    A página do exemplo pode ser acessada no link abaixo:
    http://eliasnogueira.com/arquivos_blog/selenium/datadriven/index.php

    Observação: cuidado para este item não te confundir, mas se tu for criar um script sobre uma página ajax ou não quer clicar em algum link de voltar, utilize o comando goBackAndWait antes do comando endWhile. Este comando fará com que o script emule o "voltar" do browser.


    Possíveis Erros
    1. Se você não colocar as extensões no lugar certo receberá a seguinte mensagem logo que abrir o Seleium IDE: "error loading Selenium IDE extensions: ReferenceError: Selenium is not defined". Então garanta que você colocou no campo certo (olhe a imagem)
    2. Elias, posso mudar o nome da tag testdata? Resposta: não!!! Sem esta tag o script não roda, é obrigatória!
    3. Elias, posso mudar o nome da tag test? Resposta: não!!! Sem esta tag o script não roda, é obrigatória!
    4. Elias, posso utilizar parâmetros diferentes entre os testes? Resposta: Sim! desde que os parâmetros obrigatórios estejam la. Se tu não entendeu, deixe todos iguais e o script vai rodar sem erros!

    Problemas com Firefox 20
    Para quem atualizar o Firefox para a versão 20 e estiver usando este modelo de Data Driven no Selenium IDE o seguinte erro será apresentado sempre que o Selenium IDE for aberto:

    Solução
    • Com o Selenium IDE fechado abra com um editor de texto o arquivo datadriven.js
    • Localize o seguinte trecho no arquivo:
    • Acima do trecho XML.serialize = function(node) { inclua o seguinte: var XML = {};
    • O trecho vai ficar como na imagem abaixo:
    • Abra o Selenium IDE e corra para o abraço!


    Considerações com o Selenium RC

    Se tu fores portar o teu script do Selenium IDE para ser executado por linha de comando no Selenium RC tu vais previsar baixar a user-extension do Flow Control, isso porque pelos passos que eu coloquei aqui nós a instalamos via Addon do Firefox, e se tu tentar executar o teu script com somente as outras duas user-extensions (datadriven e includeCommand4IDE) ele não vai rodar por não conhecer o comando while.

    Baixe o .js do FlowControl no site abaixo e adicione ele no parametro de execução no RC.
    http://51elliot.blogspot.com/2008/02/selenium-ide-goto.html

    ATUALIZADO: para executar os scripts via linha de comando com o Seleium RC temos o seguinte problema: temos três arquivos .js que utilizamos no Seleniun IDE (flow control, includeCommnads e dataDriven) e no Selenium RC só podemos inserir um: o user-extension.js.
    Então como executar os scripts via linha de comando???

    A resposta é: copie o conteudo de cada arquivo .js e cole crie um arquivo user-extension.js e cole com o conteudo de cada um. Quando você for fazer isso é necessário colar os arquivos na ordem que o Selenium IDE usa cada comando, que deve ser o seguinte:
    • Copie o conteudo do arquivo FlowControl.js e cole no arquivo user-extension.js
    • Copie o conteudo do arquivo includeCommand4IDE e cole no arquivo user-extension.js
    • Copie o conteudo do arquivo DataDriven e cole no arquivo user-extension.js
    E qual a vantagem de executar os scripts Data Driven com o Selenium RC: executar em diferentes browsers! :D

    A linha de comando para a execução via Selenium RC seria essa:
    java -jar selenium-server.jar -userExtension user-extensions.js -htmlSuite *iexplore "http://eliasnogueira.info" "C:\pasta\suite.html" "C:\pasta\resultado.html"

    Atenção para alterar as seguinte as seguintes informações para o local do suite e resultados que tu necessita:
    • C:\pasta\suite.html
    • C:\pasta\resultado.html
    Não esqueça que você tem que estar no diretório do Selenium Server para executar a linha de comando!

    Abraço a todos vocês e bom divertimento!!!

    terça-feira, 19 de outubro de 2010

    Projeto de Integracao Selenium x Mantis x Testlink

    Olá Pessoal!
    Como último post sobre a Integração com o Selenium e ferramentas de Gestão de Teste e Gestão de Defeitos criei um projeto em Java que integra o Selenium, Mantis e Testlink.

    É recomendado você ler os dois post's abaixo:

    Se você já leu estes dois tutoriais, continue lendo este post...
    Este projeto de exemplo vai:
    • Executar um script de teste no Selenium RC
      • O script de teste irá falhar
    • Reportar um bug no Mantis anexando uma imagem do browser no momento do erro
    • Reportar o resultado do teste (que será com falha) ao Testlink
    • Associar o bug aberto ao Caso de Teste no Testlink
    Abaixo será apresentado somente as modificações executadas para a criação de um exemplo único. Se você precisar de mais explicações sobre algum item da integração, por favor, consulte os post's anteriores.

    1. Organização
    Este projeto foi dividido nos seguintes pacotes, conforme descrito abaixo:
    •  com.blogspot.sembugs.mantis
      • ConnectMantis.java: Classe que faz a conexão com o Mantis
      • MantisReport.java: Classe que reporta o bug no Mantis
    • com.blogspot.sembugs.test
      • CasoTeste.java: Caso de Teste de exemplo
    • com.blogspot.sembugs.testlink
      • ResultadoExecucao.java: Classe que reporta o resultado da execução do teste
    • com.blogspot.sembugs.util
      • IConstantes.java: Interface com dados comuns as classes

    2. Modificações
    A seguir serão apresentados os trechos das classes que foram alterados e os devidos comentários sobre as alterações

    MantisReport.java
    Nesta classe foram feitas as seguintes alterações:
    • Linha 1: Mudança do método, que agora tem como retorno um String.
    • Linha 8: Criado um atributo local do tipo long para retornar o ID do bug cadastrado
    • Linha 12: O atributo local é transformado em uma String e atribuido a variável bugID
    • Linha 22: Adicionado o retorno do método

    PS: A classe abaixo está omitindo uma série de linhas de código, sendo apresentado apenas as mais relevantes perante as alterações.

    1:  public static String reporIssue(String sumario, String descricao, String categoria, String informacaoAdicional, String evidencia, String nomeArquivo) {  
    2:          IMCSession sessao = null;  
    3:          String arquivo = nomeArquivo + ".png";  
    4:          String bugID = null;  
    5:            
    6:          try {  
    7:        // submete o bug no Mantis  
    8:        long id = sessao.addIssue(issue);     
    9:        sessao.addIssueAttachment(id, arquivo, "image/png", Base64.decodeBase64(evidencia));  
    10:          
    11:        // retorna o ID do bug como String, para fazer o relacionanmento do bug com o Testlink  
    12:        bugID = String.valueOf(id);  
    13:          
    14:          } catch (MalformedURLException e) {  
    15:              System.err.println("Erro na URL de acesso ao Mantis");  
    16:              e.printStackTrace();  
    17:          } catch (MCException e) {  
    18:              System.err.println("Erro na comunicacao com o Mantis");  
    19:              e.printStackTrace();  
    20:          }  
    21:            
    22:      return bugID;  
    23:      }  
    24:  }  
    


    ResultadoExecucao.java
    Nesta classe foram feitas as seguintes alterações:
    • Linha 1: Foi adicionado um novo parâmetro para a utilização do método: Integer bugID. É esperado que seja passado o ID do bug cadastrado para fazer a associação com o Testlink, mas não é obrigatório
    • Linha 5: Um verificação é feita para ver se o ID do bug será passado. Se sim há uma séria de atributos que são obtidos para que o resultado de execução do caso de teste contenha o bug associado. Isso foi adicionado porque o método da API do Testlink tem uma assinatura (parâmetros) diferente do do método que não associa o bug
    • Linhas 7, 8, 9 e 10: Todos os atributos locais necessários para a associação do bug no resultado do caso de teste.
    • Linha 12: Envio dos dados de resultado do teste ao Testlink utilizando o ID do bug para associação.
    • Linhas 13 e 14: Se o bug não for passado (for null) o envio do resultado de execução para o Testlink utiliza outro método para esta tarefa.

    1:  public static void reportTestCaseResult(String projetoTeste, String planoTeste, String casoTeste, String nomeBuild, String nota, String resultado, Integer bugID) throws TestLinkAPIException {  
    2:        
    3:    TestLinkAPIClient testlinkAPIClient = new TestLinkAPIClient(DEVKEY, URL);  
    4:        
    5:    if (bugID != null) {  
    6:            
    7:      Integer projectID = TestLinkAPIHelper.getProjectID(testlinkAPIClient, PROJETO_TESTLINK);  
    8:      Integer testPlanID = TestLinkAPIHelper.getPlanID(testlinkAPIClient, projectID, PLANO);  
    9:      Integer testCaseID = TestLinkAPIHelper.getTestCaseID(testlinkAPIClient, projectID, CASO_TESTE1);  
    10:     Integer buildID = TestLinkAPIHelper.getBuildID(testlinkAPIClient, testPlanID, nomeBuild);  
    11:    
    12:     testlinkAPIClient.reportTestCaseResult(testPlanID, testCaseID, buildID, bugID, false, nota, resultado);          
    13:    } else {  
    14:        testlinkAPIClient.reportTestCaseResult(projetoTeste, planoTeste, casoTeste, nomeBuild, nota, resultado);  
    15:    }  
    16:  }  
    


    CasoTeste.java
    Esta classe é a mesma utilizado nos outros dois tutoriais, porém com nome diferente.
    Basicamente foi alterado apenas o bloco finnally do script.
    • Linha 3: Foi adicionado o método para o report do bug, atribuindo para uma variável o ID do bug que foi adicionado.
    • Linha 5: Adicionado o novo método com o parâmetro do bugID, para que o bug seja associado ao resultado de execução do caso de teste.

    PS: A classe abaixo está omitindo uma série de linhas de código, sendo apresentado apenas as mais relevantes perante as alterações.

    1:  } finally {  
    2:    if (erro) {  
    3:      String bugID = MantisReport.reporIssue("Erro no Caso de Teste de Pesquisa de Livros", "Erro em alguma validacao ou validacao", "Automacao", msgErro, evidenciaErro, "CasoTesteMantisNOK");  
    4:                    
    5:      ResultadoExecucao.reportTestCaseResult(PROJETO_TESTLINK, PLANO, CASO_TESTE1, BUILD, msgErro, resultado, Integer.parseInt(bugID));      
    6:            
    7:      CasoTeste.fail(msgErro);  
    8:    }  
    9:  }  
    


    3. Baixando o código-fonte
    O projeto completo e funcional pode ser baixado no link abaixo (18 MB):

    http://www.eliasnogueira.com/arquivos_blog/selenium/integracao/mantis_testlink/selenium-integration.zip


    4. Verificando online o resultado de execução
    Se você baixar o projeto e já executá-lo ( ) poderá ver que os resultados no Testlink e Mantis serão colocados em ambas aplicações que tenho online.

    Para acessar ambos, utilize os seguintes dados de login:
    • Usuário: convidado
    • Senha: convidado
    Dentro do Mantis, que está acessível pela URL abaixo, você verá que o bug será reportado contendo os dados que passamos para o método utilizado na classe CasoTeste.java. Atente-se para o ID do bug e o horário de criação:

    http://www.eliasnogueira.com/arquivos_blog/mantisbt-1.2.3/


    Agora no Testlink, que está acessível pela URL abaixo, veremos que o resultado reportado foi com falha, está dentro do mesmo horário de criação do bug e tem o bug associado, conforme figura.



    Bom pessoal, por enquanto é isso! Abraço a todos!

    domingo, 3 de outubro de 2010

    Integração Selenium e Testlink

    Não deixe de ler o post Integração Selenium e Mantis!

    Escopo
    Este tutorial vai apresentar como fazer a integração do Selenium com o Testlink. Mas no que consiste essa integração?
    Essa integração nada mais é do que o envio do resultado de execução do script de teste para o Testlink. Pode-se explorar muito mais do que isso, porém esse tutorial se limitará a apenas apresentar como reportar o resultado de execução do script.

    Criaremos um projeto em Java com o suporte do JUnit para a criação do script de teste com o Selenium. abaixo há uma lista de itens necessários para esse tutorial.

    O que é necessário?
    PS: apesar de no site estar o dbfacade-testlink como em outro projeto os arquivos necessários estão no link citado acima.

    1. Configurando o Testlink
    Não existe uma sequencia certa de passos, eles podem ser praticamente em qualquer ordem, porém iniciarei pelo Testlink que costuma ser um ponto crítico se não configurado.
    A versão que estou utilizando do Testlink é a 1.9 beta 6, porém você pode utilizar desde a versão 1.8.5

    1.1 Habilitar o projeto com a Automação de Teste
    Você pode ou criar um novo projeto marcando a opção Enable Test Automation (API keys) ou editando o projeto e selecionando o mesmo item.
    A imagem abaixo mostra a criação de uma novo projeto



    1.2 Editar o arquivo de configuração do Testlink
    Depois de habilitar a automação de teste para o projeto desejado é necessário habilitar o acesso a API XML-RPC do Testlink. É esta API interna que nos possibilitará o acesso aos dados do projeto.
    Você precisará alterar duas variáveis no arquivo config.inc.php do Testlink.

    Adendo: o ideal é você não alterar diretamente o arquivo config.inc.php, e sim alterar o arquivo custom_config.inc.php que estará como custom_config.inc.php.example. Basta remover o ".example" e colar as variáveis que serão apresentadas abaixo no arquivo e salvá-lo.

    As duas variáveis que você deve alterar são:
    • $tlCfg->api->enabled
    • $tlCfg->exec_cfg->enable_test_automation
    Copie as duas linhas inteiras, cole no arquivo custom_config.inc.php e altera seus valores para:
    • $tlCfg->api->enabled = TRUE;
    • $tlCfg->exec_cfg->enable_test_automation = ENABLED;
    A imagem abaixo mostra como fica o arquivo.



    1.3 Gerar uma nova chave de acesso
    Depois de habilitar o acesso a API XML-RPC e informar a ativação da automação no arquivo de configuração é necessário gerar a chave de acesso.
    Essa chave é criada por usuário e será ela que permitirá ao Testlink identificar quem está tentando acessar os serviços XML-RPC.

    Para gerar a chave vá até o menu Personal. No final da página irá existir uma seção API Interface, conforme a figura abaixo:


    Clique no botão Generate a new key. Uma chave será gerada.
    Procure não clicar mais vezes neste botão, pois ele irá gerar uma nova chave. Qualquer mudança na chave invalida a futura comunicação com os serviços do Testlink.
    Por enquanto guarde a chave que iremos utiliza-la mais tarde dentro da API dbfacede-testlink.
    A seção API interface ficará parecida com a imagem abaixo:


    2. Preparando seu ambiente de Desenvolvimento
    A preparação do ambiente vai apresentar somente as bibliotecas necessárias para fazer a integração funcionar. Não é intuito deste item ensinar alguma coisa sobre o Eclipse ou sobre Java.

    2.1 Selecionando as bibliotecas necessárias
    Para rodar o script de teste com a integração e necessário os seguintes arquivos (bibliotecas e libraries) das seguintes API's / frameworks:

    • dbfacade-testlink: necessário adicionar as seguintes bibliotecas
      • testlink-api-client-2.0.jar
      • todas as libs, exeto a junit, da pasta lib
    • Selenium RC: necessário adicionar as seguintes bibliotecas
      • selenium-server.jar
      • selenium-java-client-driver.jar
    • JUnit: necessário adicionar o JUnit 4 que já vem com o Eclipse (Add Libraries)
    Abaixo segue a imagem das bibliotecas que foram adicionadas ao Eclipse.



    Para adicionar cada biblioteca você precisa clicar com o botão direito no nome do projeto e selecionar Build Path/Configure Build Path...


    Adicone também a biblioteca do JUnit, indo ao mesmo local (Configure Build Path...) e clicando no botão Add Library. Selecione JUnit e, em seguida, JUnit 4.

    2.1 Desenvolvendo o código-fonte
    A aplicação de exemplo, que está no final do post traz o código-fonte do script de teste e mais dois arquivos de código-fonte, que serão explicados abaixo.

    A primeira coisa a fazer é entender o script de teste primeiro. O package, os imports e comentários em javadoc foram excluídos para exemplificar o funcionamento da classe.

    1:  public class CasoTesteSelenium extends TestCase implements IConstantes {  
    2:       
    3:     Selenium selenium;  
    4:     SeleniumServer server;  
    5:       
    6:     String serverHost = "localhost";  
    7:     int serverPort = 4444;  
    8:     String browserStartCommand = "*firefox";  
    9:     String browserURL = "http://www.lojaexemplodelivros.com.br/";  
    10:       
    11:     public void setUp() throws Exception {  
    12:        selenium = new DefaultSelenium(serverHost, serverPort, browserStartCommand, browserURL);  
    13:        server = new SeleniumServer();  
    14:          
    15:        server.start();  
    16:        selenium.start();  
    17:     }  
    18:       
    19:     @Test  
    20:     public void testPesquisaLivro() throws Exception {  
    21:        String resultado = null;  
    22:        String nota = null;  
    23:          
    24:        try {  
    25:           selenium.open("/");  
    26:           selenium.click("//ul[@id='nav']/li[1]/ul/li[2]/ul/li[1]/a/span");  
    27:           selenium.waitForPageToLoad("30000");  
    28:             
    29:           assertEquals("3 Item(s)", selenium.getText("//div[@id='main']/table[1]/tbody/tr/td[1]/strong"));  
    30:           assertEquals("[PRODUTO DE EXEMPLO] - Use a Cabeça! Java", selenium.getText("link=[PRODUTO DE EXEMPLO] - Use a Cabeça! Java"));  
    31:           assertEquals("[PRODUTO DE EXEMPLO] - Entendendo e Dominando o Java: para Internet", selenium.getText("link=[PRODUTO DE EXEMPLO] - Entendendo e Dominando o Java: para Internet"));  
    32:           assertEquals("[PRODUTO DE EXEMPLO] - Ajax com Java", selenium.getText("link=[PRODUTO DE EXEMPLO] - Ajax com Java"));  
    33:             
    34:           selenium.click("//img[@alt='[PRODUTO DE EXEMPLO] - Ajax com Java']");  
    35:           selenium.waitForPageToLoad("30000");  
    36:           assertTrue(selenium.isTextPresent("2x R$ 222,25 sem juros"));  
    37:           assertTrue(selenium.isTextPresent("3x R$ 148,17 sem juros"));  
    38:           assertTrue(selenium.isTextPresent("4x R$ 111,13 sem juros"));  
    39:           assertTrue(selenium.isTextPresent("5x R$ 88,90 sem juros"));  
    40:          
    41:        resultado = TestLinkAPIResults.TEST_PASSED;  
    42:          
    43:        } catch (Exception e) {  
    44:           resultado = TestLinkAPIResults.TEST_FAILED;  
    45:           nota = e.getMessage();  
    46:           e.printStackTrace();  
    47:        } finally {  
    48:           ResultadoExecucao.reportTestCaseResult(PROJETO, PLANO, CASO_TESTE1, BUILD, nota, resultado);  
    49:        }  
    50:     }  
    51:       
    52:     public void tearDown() throws Exception {  
    53:        selenium.stop();  
    54:        server.stop();  
    55:     }  
    56:  }  
    57:    
    

    Basicamente há a criação dos atributos do Selenium e SeleniumServer para a execução, os métodos setup() e tearDown() do JUnit e o caso de teste automatizado.
    Note que o bloco do caso de teste (método testPesquisaLivro) está com um try-catch. Isso é necessário para que possamos enviar a informação ao Testlink se o script falhou ou passou.

    Na linha 41 há o seguinte código:
    resultado = TestLinkAPIResults.TEST_PASSED;

    Este atributo (resultado) é uma String que armazena o status de execução. Neste caso ele está no final dos passos do script passando sucesso (TestLinkAPIResults.TEST_PASSED).
    É ele que vai dizer para o Teslink que o script passou!

    Dentro do bloco de catch (linhas 44 a 46) há os comandos que serão executados quando o script falhar por algum motivo. Note que na linha 44 passamos para a variável de resultado a informação TestLinkAPIResults.TEST_FAILED.
    Ele é que vai dizer para o Testlink que o script falhou!

    Na linha 45 a mensagem de erro gerado pelo script vai para a variável nota, para que seja adicionado a mensagem de erro no campo Nota do Testlink.

    Na linha 48, dentro do bloco de finally há o envio de resultado da execução do teste para o Testlink.
    É ele que envia os dados para o Testlink!

    Há um método é chamado (reportTestCaseResult) para passar as informações do Selenium para o Testlink.

    Classe ResultadoExecucao
    Dentro do projeto no pacote com.blogspot.sembugs há a classe ResultadoExecucao, que é a responsável por enviar o resultado do script ao Testlink. Eu gerei essa classe como chamada de uma função da API dbfacade-testlink.

    PS: package, imports e comentários em javadoc foram excluídos para exemplificar o funcionamento da classe.

    1:  public class ResultadoExecucao implements IConstantes {  
    2:    
    3:    public static void reportTestCaseResult(String projetoTeste, String planoTeste, String casoTeste, String nomeBuild, String nota, String resultado) throws TestLinkAPIException {  
    4:        
    5:      // Cria uma instância do TestLinkAPIClient para comunicação com o Testlink  
    6:      TestLinkAPIClient testlinkAPIClient = new TestLinkAPIClient(DEVKEY, URL);  
    7:      // Submete os resultados para o Testlink  
    8:      testlinkAPIClient.reportTestCaseResult(projetoTeste, planoTeste, casoTeste, nomeBuild, nota, resultado);  
    9:    
    10:    }  
    11:  }  
    

    Na linha 6 há a criação de uma instância da classe TestlinkAPIClient, passando a URL do XML-RPC do Testlink (URL) e a chave do usuário (DEVKEY).

    Muito atenção!
    A URL do XML-RPC é http://servidor/nome_testlink/lib/api/xmlrpc.php, onde:
    • servidor: é o nome do servidor onde está instalado o Testlink. Ex: localhost
    • nome_testlink: é o nome de acesso a aplicação do testlink. Ex: testlink
    A DEVKEY foi gerada lá nos primeiros passos deste post dentro do Testlink.
    Você deve alterar a DEVKEY para o seu usuário e alterar o servidor e nome_testlink para as suas configurações quando for rodar o exemplo.

    A linha 8 envia os dados para o Testlink, com alguns dados como parâmetro, que são:
    • projetoTeste: nome do projeto de teste que estamos usando no Testlink
    • planoTeste: nome do plano de teste que estamos usando no Testlink
    • casoTeste: nome do caso de teste que estamos usando no Testlink
    • nomeBuild: nome da build que estamos usando no Testlink
    • nota: nota que será inserida na execução quando houver falha na execução do script
    • resultado: resultado passado pelo script
    Interface iConstantes
    Foi criado uma interface com os dados necessários para o envio dos dados para o Testlink, que são os parâmetros que foram descritos acima.

    1:  public interface IConstantes {  
    2:    
    3:     final String DEVKEY = "84947019532f2f23e1d90b6de748cd66";  
    4:     final String URL = "http://www.eliasnogueira.info/arquivos_blog/testlink_1_9_beta6/lib/api/xmlrpc.php";  
    5:     final String PROJETO = "Integracao Selenium e Testlink";  
    6:     final String PLANO = "PT001 - Integracao Selenium e Testlink";  
    7:     final String BUILD = "Ciclo 1";  
    8:     final String CASO_TESTE1 = "Pesquisar no blog";  
    9:       
    10:  }  
    

    Note que todos os dados que estão contidos no meu Testlink estão ali. Você vai precisar alterar estes dados para fazer os seus testes.
    Todas as informações que precisam ser enviadas para o Testlink através do método reportTestCaseResult da classe ResultadoExecucao estão nesta interface.

    3. Criação do(s) Casos de Teste
    Por incrível que pareça você não precisa colocar o caso de teste com o tipo "Automatizado" e nem os passos como "Automatizado" para que o script insira o resultado de execução do caso de teste automaticamente, eles servem apenas para informação.
    Abaixo segue a imagem deste item dentro do caso de teste citadas.



    4. Execução e modificação deste tutorial
    Chegamos ao fim do tutorial. Se você deseja executar este tutorial baixe os fontes de exemplo criados no Eclipse e altere a URL de conexão com o Testlink.

    Se você alterar os dados da interface IConstantes o exemplo não funcionará, mas você pode usar o tutorial como base para a sua integração.

    Por favor mandem sugestões e feedback's se este tutorial tem ajudado ou mesmo se estiver difícil de entender (claro que dentro de seus conhecimentos de programação Java).

    4.1 Para entender mais
    Você pode fazer a integração com outras linguagens de programação com o Testlink, não especificamente com o Selenium. Na verdade essa é uma implementação em Java para qualquer aplicação desenvolvida em Java, não específica para o Selenium. O que fiz foi inserir dentro do código do Selenium a integração!

    Acesse as seguintes páginas para ter mais informações sobre os serviços XML-RPC do Testlink:

    4.2 Fontes deste tutorial
    Arquivo zipado contendo o projeto desenvolvido no Eclipse:
    http://www.eliasnogueira.com/arquivos_blog/selenium/integracao/testlink/testlink-selenium-example.zip

    Abraço a todos!