Download pdf - Guia do Demoiselle Behavedemoiselle.sourceforge.net/.../pdf/demoiselle-behave-reference.pdf · Demoiselle Behave vi O Runner é responsável pela abstração do componente que fará

Guia do Demoiselle Behave

Demoiselle Behave

iii

Demoiselle Behave ................................................................................................................. v

1. Release Notes ................................................................................................................... 1

2. Roteiro Rápido .................................................................................................................. 9

2.1. Pré Requisitos de Uso ............................................................................................... 9

2.2. Configurando o Arquétipo ........................................................................................... 9

2.3. Criação do Projeto .................................................................................................. 10

2.4. Estrutura de diretórios .............................................................................................. 12

2.5. Executando Teste ................................................................................................... 13

3. Mapeamento de Classes ................................................................................................... 17

3.1. Capturando os objetos da tela a serem utilizados ............................................................. 17

3.2. Classe de Mapeamento ............................................................................................ 18

3.3. Mapeamento Parametrizável ...................................................................................... 20

3.4. Composição de Telas (Embedded Screens) ................................................................... 21

3.5. Sistemas com AJAX (Componente Loading) ................................................................... 21

4. Como criar uma história .................................................................................................... 23

4.1. Conceito ............................................................................................................... 23

4.2. Frases pré-definidas pelo framework ............................................................................ 23

4.3. Frases pré-definidas pelo framework para manipulação de Grids .......................................... 25

4.4. Escrevendo um cenário ............................................................................................ 25

4.5. Parametrizando os cenários ....................................................................................... 26

4.6. Reusando os cenários .............................................................................................. 26

4.7. Reusando os cenários em outras histórias ..................................................................... 26

4.8. Plugin do JBehave para Eclipse .................................................................................. 27

5. Configurações do Behave .................................................................................................. 29

5.1. Configurações do Parser ........................................................................................... 29

5.2. Configurações do Runner .......................................................................................... 29

5.3. Configurações do Integration ...................................................................................... 30

5.4. Configurações do Integration - Autenticator ALM .............................................................. 31

6. Escopo de Histórias e Passos ............................................................................................ 33

6.1. DBehave Legado .................................................................................................... 33

6.2. DBehave com Suporte à Escopos ............................................................................... 33

7. Testando aplicações Desktop ............................................................................................. 35

7.1. Iniciando um projeto utilizando o Arquétipo (Modelo de Projeto) ........................................... 35

7.2. Iniciando um projeto utilizando um projeto existente (Projeto WebDriver) ................................. 35

7.3. Configurações Desktop ............................................................................................. 35

7.4. Mapeamentos ........................................................................................................ 35

8. Configurações dos Testes ................................................................................................. 37

8.1. Configuração de Passos (Steps) ................................................................................. 37

8.2. Configuração de Histórias e Cenários ........................................................................... 37

9. Execução de Testes ......................................................................................................... 39

9.1. Execução com Ghost Driver (Funcionalidade Experimental) ................................................ 39

9.2. Execução Paralela ................................................................................................... 39

9.3. Modo Background ................................................................................................... 40

9.4. Integração Contínua ................................................................................................. 41

9.5. Testes Remotos ..................................................................................................... 42

9.6. Relatórios JBehave .................................................................................................. 43

10. Conjunto de Dados ......................................................................................................... 47

10.1. Conceito ............................................................................................................. 47

10.2. Criação do XML de Dados ....................................................................................... 47

10.3. Configuração do Data Provider .................................................................................. 47

10.4. Criação da História ................................................................................................ 48

11. Testes de Regressão de Layout ........................................................................................ 49

11.1. Conceito ............................................................................................................. 49

Guia do Demoiselle Behave

iv

11.2. Pré Requisitos ...................................................................................................... 49

11.2.1. Java ........................................................................................................ 49

11.2.2. Image Magick ............................................................................................. 49

11.2.3. Projeto dbehave .......................................................................................... 50

11.2.4. Maven ...................................................................................................... 50

11.3. Configuração do Projeto dbehave .............................................................................. 50

11.3.1. Configurações Básicas do pom.xml .................................................................. 50

11.3.2. Configurações do behave.properties ................................................................. 51

11.3.3. Repositório Local de Imagens ......................................................................... 53

11.4. Pontos de Comparação ........................................................................................... 53

11.5. Rodando o Teste de Regressão ................................................................................ 53

11.6. Relatório Gerado ................................................................................................... 54

12. Colaboração .................................................................................................................. 55

12.1. Templates de Codificação ........................................................................................ 55

v

Demoiselle Behave

Behavior Driven Development (BDD) é uma técnica desenvolvida por Dan North, em 2003, com o objetivo de facilitar

a colaboração entre desenvolvedores, setores de qualidade e o cliente, em um projeto de software. Parte do princípio

de que especificando histórias de usuários, em um formato adequado, elas poderiam ser utilizadas como requisito

e como artefato de entrada para testes automatizados. Ela faz uso de uma linguagem ubíqua, a qual permite que

os testes de aceitação sejam escritos em linguagem mais próxima da de negócio.

Os testes descritos são interpretados por ferramentas especializadas, que exercitam o código do sistema, para

demonstrar se o comportamento esperado foi alcançado. As práticas do BDD incluem:

1. Envolver os stakeholders do projeto (Wikipedia)

2. Usar derivação por exemplos para descrever o comportamento de uma aplicação ou de unidades de código

3. Automatizar os exemplos para prover feedback rápido e testes de regressão;

4. Usar mocks para auxiliar na colaboração entre módulos e códigos que ainda não foram escritos

O Demoisele-Behave, comumente chamado de dbehave, é um framework que permite aos usuários automatizar

testes utilizando recursos de BDD.

A aplicação apresenta quatro módulos principais: Core, Parser, Runner e Integration. O Core é responsável pelas

principais interfaces do framework, sendo a classe Controller responsável pela orquestração das informações entre

os outros 3 módulos.

Arquitetura da ferramenta Demoiselle-Behave.

O Parser é responsável pela abstração do componente que transformará a história em código Java, para enviar ao

Runner por meio de sentenças padrões ou específicas de cada projeto.

Modelo de Funcionamento do Parser.

Demoiselle Behave

vi

O Runner é responsável pela abstração do componente que fará as manipulações de tela, como o Selenium ou até

mesmo diretamente o JUnit. O módulo Integration é responsável pela abstração do componente que irá fazer as

integrações entre a solução e as ferramentas externas da empresa como o ALM (RQM). O framework faz com que

histórias escritas em TXT sejam enviadas ao módulo Parser e, posteriormente, para o Runner, responsável por

interagir com um navegador Web ou uma tela Desktop, utilizando o framework Selenium ou Fest, respectivamente.

Funcionamento do Demoiselle-Behave

A ferramenta deve permitir que projetistas de testes escrevam histórias que possam ser lidas e acionar scripts de

testes automatizados, criados por desenvolvedores de teste.

Modelo de Uso do Demoiselle-Behave

1

Release Notes

Dica

Para reportar problemas, abrir discussões e buscar elucidar dúvidas faça uso das Issues do

GitHub - https://github.com/demoiselle/behave/issues.

Versão 1.5.3

• [Melhoria] Nova configuração para ativar e desativar logs estatísticos de execução [https://github.com/demoiselle/

behave/issues/465]

• [Melhoria] Melhoria na implementação da interface Select para Desktop [https://github.com/demoiselle/behave/

issues/457]

• [Melhoria] Melhoria no tratamento de elementos visiveis e clicáveis [https://github.com/demoiselle/behave/

issues/454]

• [Melhoria] Melhoria na velocidade de execução de testes [https://github.com/demoiselle/behave/issues/447]

• [Erro] Cenários não eram de presentes em histórias de reuso [https://github.com/demoiselle/behave/issues/446]

• [Erro] Correção do modo legado das funcionalidades de adição de histórias [https://github.com/demoiselle/

behave/issues/443]

Versão 1.5.2

• [Melhoria] Melhorias nas classes DataProviderSteps e WebAutoComplete [https://github.com/demoiselle/behave/

issues/442]

• [Melhoria] Mais melhorias gerais nos métodos de espera e busca de elementos e textos na tela [https://

github.com/demoiselle/behave/issues/435]

• [Melhoria] Permitir passagem de argumentos de linha de comando para o binário [https://github.com/demoiselle/

behave/issues/428]

• [Melhoria] Adicionada personalização de profile para RemoteWeb [https://github.com/demoiselle/behave/

issues/415]

• [Melhoria] Permite desabilitar os screenshots com a propriedade behave.parser.screenshot.enabled [https://


• [Melhoria] Agora quando um passo esta pendente o teste falha [https://github.com/demoiselle/behave/issues/409]

• [Melhoria] Por padrão agora também é gerado o formato XML do JBehave [https://github.com/demoiselle/behave/

issues/407]

• [Melhoria] Diversas melhorias para o funcionamento do Fest para Java Desktop [https://github.com/demoiselle/

behave/issues/404]

• [Erro] Ajustes para o funcionamento do GhostDriver [https://github.com/demoiselle/behave/issues/403]

• [Erro] Ajustes para funcionar o Google Chrome 34 [https://github.com/demoiselle/behave/issues/399]

• [Melhoria] Nova funcionalidade de escopo de Passos e Histórias (Verificar documentação) [https://github.com/

demoiselle/behave/issues/397]

https://github.com/demoiselle/behave/issues

https://github.com/demoiselle/behave/issues/465














































Capítulo 1. Release Notes

2

• [Melhoria] Melhoria em algumas frases pré definidas adicionando a possibilidade de @When para os passos de

TableSteps [https://github.com/demoiselle/behave/issues/394]

• [Melhoria] Adição de frase para enviar texto e acionar um evento no campo texto [https://github.com/demoiselle/

behave/issues/387]

• [Melhoria] Melhorias para testes Desktop com componente DesktopSelect e JTextField [https://github.com/


• [Melhoria] Melhorias gerais nos métodos de espera e busca de elementos e textos na tela [https://github.com/


• [Melhoria] Permitir que algumas das frases pré definidas sejam utilizadas com @When [https://github.com/


• [Melhoria] Melhoria na utilização de telas em projetos Desktop [https://github.com/demoiselle/behave/issues/379]

• [Melhoria] Pequena correção de texto ao dar erro de texto não encontrado [https://github.com/demoiselle/behave/

issues/376]

• [Erro] Correção na leitura de histórias com internacionalização [https://github.com/demoiselle/behave/issues/376]

• [Melhoria] Implementação de profile para Chrome [https://github.com/demoiselle/behave/issues/375]

• [Melhoria] Agora o Chrome levanta com todas as extensões desabilitadas por padrão [https://github.com/


• [Erro] Correção de erros com internacionalização [https://github.com/demoiselle/behave/issues/373]

• [Melhoria] Não é mais permitida a adicionar a mesma história 2 vezes no mesmo teste [https://github.com/


• [Melhoria] Ajuste para imprimir em debug no console sempre que algo é consultado ou inserido no DataProvider

[https://github.com/demoiselle/behave/issues/366]

Versão 1.5.1

• [Melhoria] Inclusão do navegador GhostDriver em modo experimental [https://github.com/demoiselle/behave/

issues/363]

• [Bug] Correção de um problema que não permitia aumentar o timeout padrão [https://github.com/demoiselle/

behave/issues/362]

• [Bug] Refatoração completa do código da integração com a ALM corrigindo um problema de limpeza de diversos

dados [https://github.com/demoiselle/behave/issues/361]

• [Melhoria] Novo componente de UI para trabalhar com o p:editor do primefaces [https://github.com/demoiselle/

behave/issues/360]

• [Bug] Correção de bug que limpava alguns dados quando a integração com a ALM era feita [https://github.com/


• [Melhoria] Atualização da versão do WebDriver para a versão 2.46 [https://github.com/demoiselle/behave/

issues/354]

• [Melhoria] Padronização dos comportamentos de Radio e do Checkbox [https://github.com/demoiselle/behave/

issues/353]

• [Melhoria] Melhorias na manipuação de elementos Primefaces Radio e Check [https://github.com/demoiselle/

behave/issues/351]



























































3

• [Melhoria] Atualização da versão do JBehave para a versão 4 [https://github.com/demoiselle/behave/issues/348]

Versão 1.5.0

• [Melhoria] Nova propriedade para zoom out para screenshot [https://github.com/demoiselle/behave/issues/345]

• [Melhoria] Melhorias no primefaces grid e novo parâmetro para a captura da tela nos erros [https://github.com/


• [Melhoria] Melhoria na integração ALM, agora um cenário falha quando uma ou mais linhas dos exemplos falha


• [Melhoria] Integração com Image Magick para testes de regressão de layout [https://github.com/demoiselle/

behave/issues/309]

Versão 1.4.4

• [Melhoria] Melhoria na verificação de valor selecionado de Select do Primefaces [https://github.com/demoiselle/

behave/issues/332]

• [Melhoria] Criação de passos para validação de visibilidade ou não de texto, componentes e componentes

parâmetrizados [https://github.com/demoiselle/behave/issues/259]

Versão 1.4.3

• [Melhoria] Melhoria na integração com a ALM, agora os testes automatizados selecionarão o "Tipo

de Execução" com valor "Automatizado" no Caso de Teste, ou o que for informado na propriedade

behave.integration.alm.categoryTipoExecucao [https://github.com/demoiselle/behave/issues/329]

• [Melhoria] Adicionado suporte a input text para a frase de armazenagem de texto [https://github.com/demoiselle/

behave/issues/322]

• [Melhoria] Reorganização dos passos em classes distintas [https://github.com/demoiselle/behave/issues/321]

• [Melhoria] Adição do suporte a radio button na frase de "clique no elemento..." [https://github.com/demoiselle/

behave/issues/320]

• [Melhoria] Novos passos para manipulação de Grids do Primefaces [https://github.com/demoiselle/behave/

issues/319]

• [Melhoria] Melhoria na parametrização de cenários [https://github.com/demoiselle/behave/issues/318]

• [Melhoria] Novo atributo forceWaitLoading no ElementMap que força o dbehave a aguardar o Loading aparecer


• [Melhoria] Agora mesmo utilizando o Meta @casodeteste o caso de teste será associado ao plano [https://


• [Melhoria] Atualização da versão do WebDriver de 2.44 para a 2.45 [https://github.com/demoiselle/behave/

issues/314]

Versão 1.4.2

• [Bug] Correção de bug da versão 1.4.1 na execução de testes para a plaforma windows [https://github.com/


Versão 1.4.1

• [Bug] Correção de um problema na verificação da presença do loading [https://github.com/demoiselle/behave/

issues/301]



















































4

• [Melhoria] Atualização da versão do Selenium para a 2.44 (2014-10-23) [https://github.com/demoiselle/behave/

issues/299]

• [Bug] Correção de um problema com a integração ALM - Sobrescrita de Aprovações [https://github.com/


• [Bug] Correção de um problema com a integração ALM - Sobrescrita de Categorias do Plano [https://github.com/


• [Bug] Melhoria no tratamento de IFrames sem Source [https://github.com/demoiselle/behave/issues/296]

• [Melhoria] Adicionando a interface Link como tipo de elemento para a frase que move o mouse sobre um elemento


• [Melhoria] Melhoria na documentação do projeto [https://github.com/demoiselle/behave/issues/289]

• [Bug] Correção de um problema com passo para verificação de campos não editáveis e visíveis [https://


• [Bug] Correção de um problema na frase que aguarda elementos em combos do Primefaces [https://github.com/


• [Melhoria] Novos Componentes WebAutoComplete e WebImage [https://github.com/demoiselle/behave/

issues/285]

• [Bug] Erro na integração com ALM quando existiam requisitos ligados ao plano de testes [https://github.com/


Versão 1.4.0

• [Melhoria] Melhoria do Screenshot no módulo Desktop (Fest) [https://github.com/demoiselle/behave/issues/284]

• [Melhoria] Nova funcionalidade de seleção de valor por índice dentro de combo do Primefaces [https://github.com/


• [Melhoria] Agora na integração com a ALM os cenários pendentes, agora são marcados no ALM como blocked


• [Bug] Correção na verificação de elementos visíveis e desabilitados [https://github.com/demoiselle/behave/

issues/278]

• [Melhoria] Evita que os cenários reutilizáveis sejam executados depois de utilizados [https://github.com/


• [Melhoria] Novos passos para a limpeza de campos [https://github.com/demoiselle/behave/issues/270]

• [Melhoria] Correção de problemas de execução no Windows [https://github.com/demoiselle/behave/issues/266]

• [Melhoria] Corrigido um problema que não limpava as histórias corretamente ao final do teste [https://github.com/


• [Melhoria] Melhoria no preenchimento de campos [https://github.com/demoiselle/behave/issues/253]

• [Bug] Corrigido erro ao enviar os caractere de maior e menor [https://github.com/demoiselle/behave/issues/251]

• [Melhoria] Melhoria na utilização do DataProvider nos passos comuns [https://github.com/demoiselle/behave/

issues/250]

• [Melhoria] Duas novas funcionalidades adicionadas: Configuração de Passos (Steps) e Configuração de Histórias

e Cenários [https://github.com/demoiselle/behave/issues/248]


























































5

• [Melhoria] Criada nova propriedade behave.parser.delayBetweenSteps para que seja adicionado um delay entre

cada execução de passo durante o teste [https://github.com/demoiselle/behave/issues/245]

• [Melhoria] Melhoria na velocidade de execução dos testes, em média a execução dos testes ficaram 2 vezes mais

rápidos [https://github.com/demoiselle/behave/issues/240]

• [Melhoria] Nova funcionalidade que permite a utilização de um conjunto de dados externo em XML nas histórias


• [Melhoria] Nova propriedade behave.integration.alm.autoAssociateTestCaseInPlan que permite desligar a

associação automática entre Casos de Teste e os Planos no RQM [https://github.com/demoiselle/behave/

issues/235]

• [Melhoria] Atualização no material de treinamento [https://github.com/demoiselle/behave/issues/229]

Versão 1.3.2

• [Bug] Correção de um problema que ocorria quando utilizava o meta info @casodeteste na integração com a

ALM [https://github.com/demoiselle/behave/issues/223]

• [Bug] Correção de um problema com o JBehave que impedia que fossem gerados relatórios no Windows [https://


• [Melhoria] Inclusão de valores dos campos da tabela de exemplos nos passos dos cenários de testes criados no

alm [https://github.com/demoiselle/behave/pull/165]

• [Melhoria] Grava a hierarquia da janela ativa no arquivo html do relatório do jbehave para fest [https://github.com/

demoiselle/behave/pull/169]

• [Melhoria] Permitir o uso de um firefox não padrão [https://github.com/demoiselle/behave/pull/173]

• [Melhoria] Adicionado novo componente componente DesktopLink [https://github.com/demoiselle/behave/

pull/175]

• [Melhoria] Adicionado novos componentes DesktopRadio e DesktopCheckbox [https://github.com/demoiselle/

behave/pull/180]

• [Melhoria] Adicionado novo componente para o rich:fileupload [https://github.com/demoiselle/behave/pull/186]

• [Melhoria] Adicionado novo componente para o rich:inputNumberSpinner [https://github.com/demoiselle/behave/

pull/187]

• [Melhoria] Adicionado novo passo: será exibido o valor "$text" em "$elementName" referente a

"$locatorParameters" [https://github.com/demoiselle/behave/pull/190]

• [Bug] Correção de bug no preenchimento de campos no IE8+ para Windows 7 64-bits [https://github.com/


• [Melhoria] Melhoria na integração com a ALM permitindo informar a área de projeto com ou sem url encoding

[https://github.com/demoiselle/behave/pull/199]

• [Melhoria] Permitir o uso da janela do navegador em modo maximizado [https://github.com/demoiselle/behave/

issues/204]

• [Melhoria] Permitir alternar de janela no navegador através da url [https://github.com/demoiselle/behave/pull/205]

• [Melhoria] Permitir reutilizar cenários de uma história sem executá-la [https://github.com/demoiselle/behave/

pull/212]

• [Melhoria] Nova propriedade para controlar o timeout das histórias no parser [https://github.com/demoiselle/

behave/pull/214]





















https://github.com/demoiselle/behave/pull/165







































6

• [Melhoria] Melhoria na identificação do arquivo de screenshot de erro [https://github.com/demoiselle/behave/

pull/215]

• [Bug] Corrigi o erro 'Nenhuma página selecionada' quando mais de uma classe herda de CommonSteps [https://

github.com/demoiselle/behave/pull/219]

• [Melhoria] Atualização do componente Selenium para funcionar com navegadores mais recentes [https://


• [Melhoria] Atualização das propriedades do framework na documentação [https://github.com/demoiselle/behave/

pull/222]

• [Melhoria] Atualização da aplicação treino e inclusão no repositório do GitHub na pasta "sample/treino-app"


Versão 1.3.1

• [Melhoria] Tratamento da exceção StaleElementReferenceException por meio de um proxy [https://github.com/


• [Nova Funcionalidade] Possibilitar a configuração do framework para execução de testes remotos [https://


• [Melhoria] Tratamento do caracter # no envio dos dados para a ALM [https://github.com/demoiselle/behave/

pull/145]

• [Melhoria] Tratamento de elementos visíveis mais não clicáveis [https://github.com/demoiselle/behave/pull/147]

• [Novo Componente] Novo componente Web de tela RichTextEditor (CKEditor) [https://github.com/demoiselle/

behave/pull/148]

• [Melhoria] Atualização das dependências do framework [https://github.com/demoiselle/behave/pull/151]

• [Melhoria] Melhoria na velocidade de execução e estabilidade dos testes [https://github.com/demoiselle/behave/

pull/152]

• [Bug] Tratamento de campos com máscara no primefaces [https://github.com/demoiselle/behave/issues/161]

Versão 1.3.0

• [Nova Funcionalidade] Implementação para locator com parâmetros usando a notação: %paramN% [https://


• [Nova Funcionalidade] Implementação de composição de telas a partir da anotação @Embedded [https://


• [Melhoria] Novas frases para tratamento de alertas em javascript [https://github.com/demoiselle/behave/

issues/124]

• [Melhoria] Tratamento de frames na busca por objetos de tela [https://github.com/demoiselle/behave/issues/74]

• [Melhoria] Implementação do componente PrimeFaces Tree [https://github.com/demoiselle/behave/pull/121]

• [Melhoria] Internacionalização de mensagens do Framework [https://github.com/demoiselle/behave/issues/71]

• [Melhoria] Incorporando a utilização de chaves nas ações de referência [https://github.com/demoiselle/behave/

pull/118]

• [Melhoria] Tratamento da exceção StaleElementReferenceException no WebSelect [https://github.com/


























































7

• [Bug] Problema com o common steps: Correção na frase "então será exibido" [https://github.com/demoiselle/

behave/issues/75]

• [Bug] Problema com o common steps: Correção na frase "seleciono a opção" [https://github.com/demoiselle/

behave/issues/115]

Versão 1.2.0

• [R09] Permitir execução para interface Desktop - (Java Swing) [https://github.com/demoiselle/behave/issues/11]

• [R12] Execução dos testes em modo background [https://github.com/demoiselle/behave/issues/14]

• [R14] Controle de execuções em paralelo [https://github.com/demoiselle/behave/issues/16]

• [Bug] Erro na Integração ALM [https://github.com/demoiselle/behave/issues/44]

• [Bug] Correção para o Bug: Problema com a palavra-chave Funcionalidade [https://github.com/demoiselle/

behave/issues/43]

• [Melhoria] - Material de Treinamento [https://github.com/demoiselle/behave/issues/20]

• [Melhoria] Permitir a utilização de cenários parametrizados juntamente com o reuso de cenários [https://


• [Melhoria] Melhoria no relatório do JBehave com Screenshot de erros [https://github.com/demoiselle/behave/

issues/20]

Versão 1.1.0

• [R01] Reuso de dados entre histórias [https://github.com/demoiselle/behave/issues/4]

• [R03] Integração com o ALM – (RQM, SCM, RTC, Agent Builder) [https://github.com/demoiselle/behave/issues/5]

• [R06] Execução parametrizável [https://github.com/demoiselle/behave/issues/8]

• [R07] Reuso de componentes para interação com a tela [https://github.com/demoiselle/behave/issues/9]

• [R10] Permitir a execução de testes além de interface gráfica [https://github.com/demoiselle/behave/issues/12]

• [Melhoria] Documentação de Referência [https://github.com/demoiselle/behave/issues/17]

Versão 1.0.0

• [R02] Reuso de histórias [https://github.com/demoiselle/behave/issues/2]

• [R04] Execução dos testes na Integração continua [https://github.com/demoiselle/behave/issues/6]

• [R05] Integração com IDEs de desenvolvimento homologadas [https://github.com/demoiselle/behave/issues/7]

• [R08] Desacoplamento com as tecnologias de referência [https://github.com/demoiselle/behave/issues/10]

• [R11] Permitir debug da execução [https://github.com/demoiselle/behave/issues/13]

• [R13] Simplicidade de montagem de ambiente [https://github.com/demoiselle/behave/issues/15]

• [Melhoria] Estrutura do Projeto - Padrão Demoiselle [https://github.com/demoiselle/behave/issues/3]




















































8

9

Roteiro RápidoEsta seção apresenta um roteiro rápido para criação e configuração de um projeto com uso do framework Demoiselle

Behave.

2.1. Pré Requisitos de Uso

1. Eclipse 4.2 (Juno) - Link para download [http://www.eclipse.org/downloads/download.php?file=/technology/epp/

downloads/release/juno/SR2/eclipse-jee-juno-SR2-linux-gtk.tar.gz]

2. Plugin para Maven no Eclipse ou Maven na linha de comando (mvn)

3. Linux

4. JDK 1.6

2.2. Configurando o Arquétipo

O framework Demoiselle Behave disponibiliza um arquétipo Maven para faciliar a criação de projetos. O primeiro

passo na configuração do arquétipo consiste em configurar o repositório. Para tanto deve ser acessado o menu

Windows>Preferences do Eclipse.

Menu de Preferência.

http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/juno/SR2/eclipse-jee-juno-SR2-linux-gtk.tar.gz



Capítulo 2. Roteiro Rápido

10

O próximo passo deverá ser o acionamento do botão Add Remote Catalog.

Clicar no botão Add Remote Catalog.

Em seguida deverá ser informado no campo Catalog File url: http://demoiselle.sourceforge.net/repository/

archetype-catalog.xml No campo Description informe: Framework Demoiselle

Preenchendo Catálogo Remoto.

2.3. Criação do Projeto

O primeiro passo na criação de um projeto Demoisele-Behave é criar um projeto Maven com o arquétipo adequado

ao projeto de testes. Neste tutorial será utilizado o arquétipo jbehave-selenium-archetype. O primeiro passo é

escolher a opção File>New>Other>Maven>Maven Project.

Criação do Projeto

11

Escolhendo Maven Project.

Escolher o catálogo Demoisele-Behave e escolher o arquétipo do Selenium.

Escolhendo o arquétipo jbehave-selenium-archetype.


12

Preencher o Group Id e Artifact Id e finalize a criação do projeto.


2.4. Estrutura de diretórios

O projeto criado a partir do arquétipo possui os diretórios src/test/java e src/test/resources. No diretório src/test/

resource estarão contidas as histórias de usuários. No diretório src/test/java estarão contidos os Steps do demoiselle

bem como os objetos responsáveis pela identificação das telas envolvidas nos testes e seus objetos.

Executando Teste

13

Estrutura de pastas do projeto criado a partir do arquétipo.

2.5. Executando Teste

A classe MyTest é responsável pela configuração da pasta onde estão localizadas as histórias de usuários bem

como os passos (Steps) a serem adicionados ao projeto.

Classe MyTest.

O projeto criado já possui um exemplo que realiza vários passos no site do Demoiselle Behave. Para executar o

teste basta clicar com o botão direito na classe MyTest e escolher Run as>JUnit Test.


14

Classe MyTest

O framework inicia o Driver e abre o navegador. As ações das histórias poderão ser vistas no console da IDE como

na imagem abaixo.

Saída do console

Abaixo segue a história executada pelo framework:

Funcionalidade: Acesso ao Projeto Demoiselle Behave

Narrativa:

Para obter informações sobre o projeto Demoiselle Behave

Como um visistante

Desejo ter acesso a documentação, fórum e demais informações sobre o projeto

Cenário: Site do DBehave

Dado que vou para a tela "dbehave"

Então será exibido "dbehave - projeto mantido pelo SERPRO"

Cenário: Lendo dúvidas

Dado que vou para a tela "Github"

Então será exibido "Demoiselle Behave"

Então será exibido "http://dbehave.com"

Executando Teste

15

Quando clico em "Dúvidas e Questões"

Então será exibido "New issue"

Por exemplo, no segundo cenário, o framework associa o link "Dúvidas e Questões" com o elemento linkIssues

da classe MyPages criada de forma a mapear os objetos da tela. O Elemento locatorType informa o tipo de

reconhecimento de objetos que será utilizado no framework. No exemplo, será localizado o elemento cujo XPath

seja "//a//span[./text()='Issues']".

@ScreenMap(name = "Github", location = "https://github.com/demoiselle/behave")

public class Main {

@ElementMap(name = "Dúvidas e Questões", locatorType = ElementLocatorType.XPath, locator =

"//a//span[./text()='Issues']")

private Link linkIssues;

@ElementMap(name = "uma dúvida", locatorType = ElementLocatorType.XPath, locator = "(//

a[contains(@class, 'issue-title')])[2]")

private Link linkIssue;

}

16

17

Mapeamento de ClassesEsta seção apresenta um roteiro para criação de scripts visuais.

3.1. Capturando os objetos da tela a serem utilizados

O primeiro passo na criação de um script no Demoiselle-Behave é a escolha dos objetos visuais que serão utilizados.

Os objetos poderão ser identificados de diversas formas como Id, XPath ou CSS. Estas diferentes formas de

encontrar um objeto na tela são denominadas localizadores. Neste tutorial serão utilizadas algumas ferramentas

de apoio para a escolha dos objetos. De forma exemplificativa o tutorial apresentará um exemplo onde o usuário

buscará uma informação na página do SERPRO(www.serpro.gov.br).

Localizadores.

O próximo passo é utilizar uma ferramenta de apoio para escolher os objetos. O XPath Checker e o FirePath são

ferramentas que permitem obter o Xpath de objetos na tela (https://addons.mozilla.org/pt-br/firefox/addon/xpath-

checker/)(https://addons.mozilla.org/en-US/firefox/addon/firepath/).

Capítulo 3. Mapeamento de Classes

18

Ferramenta XPath Checker

Ferramenta FirePath

Após instalação das ferramentas de apoio devem ser escolhidos os objetos que devem interagir com a tela. De

forma a exemplificar o processo será realizada uma pesquisa na página do SERPRO (www.serpro.gov.br). Será

selecionado o campo de busca e o botão de pesquisa. Utilizando o firepath será identificado o id do campo de

pesquisa.

Utilizando firepath para descobrir xpath de objeto

Uma vez utilizado o firepath descobre-se que o xpath do campo de busca possui o valor .//*[@id='searchGadget']

e o xpath do botão de busca possui o valor .//*[@id='livesearch0']/div/input[1] .

3.2. Classe de Mapeamento

O próximo passo será implementar uma classe com o mapeamento dos objetos a serem testados e seus

identificadores.

package packageName;

import br.gov.frameworkdemoiselle.behave.annotation.ElementLocatorType;

import br.gov.frameworkdemoiselle.behave.annotation.ElementMap;

import br.gov.frameworkdemoiselle.behave.annotation.ScreenMap;

import br.gov.frameworkdemoiselle.behave.runner.ui.Button;

Classe de Mapeamento

19

import br.gov.frameworkdemoiselle.behave.runner.ui.TextField;

@ScreenMap(name = "Tela Inicial", location = "https://www.serpro.gov.br")

public class MyPage {

@ElementMap(name = "Campo de Busca", locatorType = ElementLocatorType.XPath, locator = ".//

*[@id='searchGadget']")

private TextField searchField;

@ElementMap(name = "Estou com sorte", locatorType = ElementLocatorType.XPath, locator = ".//

*[@id='livesearch0']/div/input[1]")

private Button button;

}

O motor do framework escolhe automaticamente que ação será realizada dependendo do tipo de objeto aplicado

ao elemento da interface gráfica. No exemplo acima o tipo Button indica que a ação de clique deve ser realizada.

Outros tipos de elementos são CheckBox, Link, Radio, Screen, Select e TextField. Para cada elemento visual foi

criada uma interface que é implementada por uma classe que define como a ação deve ser realizada.

package br.gov.frameworkdemoiselle.behave.runner.ui;

import br.gov.frameworkdemoiselle.behave.runner.ui.base.BaseUI;

public interface Radio extends BaseUI {

public void click();

}

A seguir segue implementação da classe Radio para Web utilizando Selenium.

package br.gov.frameworkdemoiselle.behave.runner.webdriver.ui;

import br.gov.frameworkdemoiselle.behave.runner.ui.Radio;

public class WebRadio extends WebBase implements Radio {

public void click() {

waitElement(0);

getElements().get(0).click();

}

}

A implementação da classe para a interface visual é configurada utilizando o conceito de SPI no framework. Para

cada interface existe um arquivo que indica qual implementação será escolhida para cada interface.


20


3.3. Mapeamento Parametrizável

É possível por meio de frases pré definidas parametrizar o locator.

Em uma determinada situação será necessário que seja selecionado um botão que está presente em uma linha que

possui na sua primeira coluna a palavra "Brasil", para facilitar esta tarefa foram criados os locators parametrizáveis.

O primeiro passo será criar o mapeamento na classe como mostra o exemplo abaixo.

@ElementMap(name = "Excluir", locatorType = ElementLocatorType.XPath, locator = "(//

tr[contains(@id, 'tr-identification')][.//text()='%param1%']//button)[1]")

private Button botao;

Perceba que no locator existe o trecho %param1%, esse é o identificador para que na história seja passado algum

texto para ser inserido neste local, como por exemplo:

Quando clico em "Excluir" referente a "Brasil"

Também é possível passar mais de um parâmetro para a frase como no exemplo abaixo (os valores devem ser

separados por vírgula):

// Mapeamento do Campo

@ElementMap(name = "Excluir", locatorType = ElementLocatorType.XPath, locator = "(//

tr[contains(@id, '%param1%')][.//text()='%param2%']//button)[1]")

private Button botao;

// Frase na história

Composição de Telas (Embedded Screens)

21

Quando clico em "Excluir" referente a "obra, valor"

As seguintes frases permitem a parametrização do texto do locator:

• Quando clico em "Name" referente a "Param1,Param2..."

• Quando seleciono a opção "Name" referente a "Param1,Param2..."

• Quando clico na linha da tabela "Name" referente a "Param1,Param2..."

3.4. Composição de Telas (Embedded Screens)

O framework fornece uma anotação (@Embedded) que permite que sejam reutilizadas telas dentro de outras telas.

Como exemplo vamos utilizar uma tela de login abaixo:

@ScreenMap(name = "Tela de Login", location = "/")

public class LoginPage {

@ElementMap(name = "Campo Usuário", locatorType = ElementLocatorType.XPath, locator = "(//

input[contains(@id, 'formLogin')][contains(@type, 'text')])[1]")

private TextField campoUsuario;

@ElementMap(name = "Campo Senha", locatorType = ElementLocatorType.XPath, locator = "(//

input[contains(@id, 'formLogin')][contains(@type, 'password')])[1]")

private TextField campoSenha;

@ElementMap(name = "Entrar", locatorType = ElementLocatorType.XPath, locator = "(//

button[contains(@id, 'formLogin')][contains(@type, 'submit')])[1]")

private Button botaoEnviar;

}

Para que a tela de login seja utilizada em várias partes públicas do sistema basta que em qualquer ScreenMap

seja criado um atributo da seguinte maneira:

@Embedded

private LoginPage loginPage;

Isso fará com que a tela de login seja incorporada na tela que possuir o atributo com a anotação.

3.5. Sistemas com AJAX (Componente Loading)

O framework fornece um componente de tela chamado Loading, que auxilia no tratamento das ações AJAX que

normalmente têm como comportamento padrão abrir um elemento em cima do conteúdo com uma imagem/texto

de "Carregando...", impedindo o acesso aos outros elementos de tela, enquanto a imagem/texto é exibida. O

componente tem como objetivo aguardar que a imagem desapareça para ir para o próximo passo. Para utilizar o

componente, adicione em qualquer ScreenMap um ElementeMap com tipo Loading como mostra abaixo:

@ElementMap(name = "Carregando", locatorType = ElementLocatorType.XPath, locator = "/HTML/BODY/

DIV[2]/DIV[1]/SPAN[@id='ui-dialog-title-j_idt9']")


22

private Loading loading;

Basta adicionar o Loading em um ScreenMap para que funcione para todas as telas.

Dica

O problema que este componente resolve pode ocorrer de forma aleatória em sistemas com

AJAX e que possuam a image/texto de "Carregando..." nas ações. Quando ocorre uma lentidão

no sistema a imagem/texto é mantida mais tempo que o normal impedindo que o próximo passo

seja executado.

A partir da versão 1.4.3 a anotação @ElementMap possui um atributo forceWaitLoading que por padrão é false. Em

casos muito específicos ele tem como objetivo forçar a espera do elemento de loading mapeado aparacer, ou seja,

quando o elemento estiver com esta propriedade forceWaitLoading = true o dbehave irá aguardar pelo maxWait

o loading aparecer e em seguinda desaparecer antes de executar a próxima ação. Abaixo esta um exemplo de

utilização:

@ElementMap(name = "NOME DO ELEMENTO NA HISTÓRIA", forceWaitLoading = true, locatorType =

ElementLocatorType.Id, locator = "ID DO ELEMENTO")

private TextField field;

23

Como criar uma históriaNeste capítulo estão descritos os termos, frases e regras para criação e reúso de cenários de teste realizáveis por

meio do framework Behave.

4.1. Conceito

No BDD, há três palavras-chave:

• Dado

• Quando

• Então

O framework Behave estende o vocabulário padrão do BDD, adicionando novos termos:

• E

• Mas

Um cenário é um conjunto de frases que utilizam as palavras-chave descritas acima para descrever um

comportamento esperado pelo sistema.

Dado que estou na tela de login do sistema

Quando informo usuário "demoiselle" e senha "behave"

E clico no botão "Entrar"

Então será exibida a página de boas vindas

Uma história é um conjunto de cenários que descrevem uma funcionalidade do sistema, ou uma parte dela.

4.2. Frases pré-definidas pelo framework

O framework Behave foi construído para diminuir o esforço gasto para definir os vários cenários de teste de um

sistema. Algumas frases estão embutidas no framework para facilitar o mapeamento das classes de teste. São elas:

• [Dado que | Quando | Então] vou para a tela "<título da tela>"

• [Dado que | Quando | Então] estou na tela "<título da tela>"

• [Quando | Então] clico em "<nome do elemento>" referente a "<lista de parâmetros>"

• [Quando | Então] clico em "<texto do botão/link>"

• [Quando | Então] seleciono a opção "<texto da opção>"

• [Quando | Então] seleciono a opção de índice "<indice>" no campo "<nome do elemento>"

• [Quando | Então] seleciono a opção "<nome do elemento>" referente a "<lista de parametros>"

Capítulo 4. Como criar uma hi...

24

• [Quando | Então] seleciono a opção de valor "<valor>" no campo "<nome do elemento>"

• [Dado que | Quando | Então] informo "<valor>" no campo "<nome do campo>"

• [Quando] limpo o valor do campo "<nome do campo>"

• [Quando] não informo valor para o campo "<nome do campo>"

• [Dado que | Quando] informo "<tabela de exemplos>"

• [Quando] informo os campos "<tabela de exemplos>"

• [Então] será exibido "<texto>"

• [Então] será exibido na "<nome do elemento>" o valor "<valor>"

• [Então] será exibido o valor "<texto>" em "<nome do elemento>" referente a "<lista de parâmetros>"

• [Dado que | Quando | Então] "<nome do elemento>" não está visível

• [Dado que | Quando | Então] obtenho "<texto>" do campo "<nome do campo>"

• [Dado que | Quando | Então] informo "<chave>" com valor "<nome do campo>"

• [Quando] movo o mouse sobre "<elemento>"

• [Quando] clico na linha da tabela "<tabela>" referente a "<texto>"

• [Dado que | Quando | Então] confirmo a caixa de diálogo

• [Dado que | Quando | Então] cancelo a caixa de diálogo

• [Dado que | Quando | Então] informo na caixa de diálogo "<texto>"

• [Então] será exibido na caixa de diálogo "<texto>"

• [Dado que | Quando | Então] informo um número randomico com prefixo "<texto do prefixo>" no campo "<nome

do campo>"

• [Quando] informo um número randomico no campo "<nome do campo>"

• [Dado que | Quando | Então] defino a variável "<nome da variável>" com valor "<texto>"

• [Quando | Então] imprimo no console o valor da variável "<nome da variável>"

• [Quando] seleciono "<registro do conjunto de dados>" do conjunto de dados "nome do conunto de dados"

• [Então] não será exibido "<texto>"

• [Então] não será exibido na "<elemento>" o valor "<texto>"

• [Então] não será exibido no "<elemento>" o valor "<texto>"

• [Então] não será exibido o valor "<texto>" em "<elemento>" referente a "<lista de parâmetros>"

• [Dado que | Quando | Então] "<elemento>" referente a "<lista de parâmetros>" não está visível

• [Então] "<elemento>" está visível

• [Então] "<elemento>" está desabilitado

Frases pré-definidas pelo framework para manipulação de Grids

25

• [Dado que | Quando | Então] aguardo o elemento "<elemento>" referente a "<lista de parâmetros>" estar visível,

clicável e habilitado

• [Dado que | Quando | Então] o elemento "<elemento>" referente a "<lista de parâmetros>" está visível e

desabilitado

Dado que estou na tela "Login"

Quando informo "demoiselle" no campo "Usuário:"

E informo "behave" no campo "Senha:"

Quando clico em "Entrar"

Então será exibido "Seja bem vindo"

4.3. Frases pré-definidas pelo framework para

manipulação de Grids

• [Quando] armazeno a célula "<linha>","<coluna>" da tabela "<tabela>" em "<container>

• [Quando] armazeno a coluna "<coluna>" da tabela "<tabela>" em "<container>"

• [Quando] comparo o texto da célula "<linha>","<c>" da tabela "<tabela>" com "<container>"

• [Quando] comparo o texto da coluna "<coluna>" da tabela "<tabela>" com "<container>"

• [Quando] clico na célula "<linha>","<coluna>" da tabela "<tabela>"

• [Quando] clico na coluna "<coluna>" da tabela "<tabela>"

• [Quando] escolho a opção "<value>" na célula "<l>","<c>" da tabela "<tabela>"

• [Quando] escolho a opção "<value>" na coluna "<c>" da tabela "<tabela>"

• [Quando] informo o texto "<value>" na célula "<l>","<c>" da tabela "<tabela>"

• [Quando] informo o texto "<value>" na coluna "<c>" da tabela "<tabela>"

4.4. Escrevendo um cenário

As histórias escritas para o Behave devem estar em arquivos com a extensão ".story". Cada arquivo

".story" pode conter vários cenários de teste. Esta extensão pode ser alterada modificando o valor da chave

"behave.parser.story.extension.converted" no arquivo behave.properties. Os termos aceitos pelo framework devem

sempre estar no início das frases, mesmo que precedidas por espaços. As frases descritas nos cenários

devem estar cada uma em uma linha diferente. O cenário é, por padrão, iniciado com o termo "Cenário:",

no caso da história estar no idioma português. Este termo pode ser alterado modificando o valor da chave

"behave.parser.identification.scenario.pattern.<idioma>" no arquivo behave.properties.

Cenário: Acessar o sistema com usuário demoiselle e senha behave

Dado que estou na página "Login"

Quando informo "demoiselle" no campo "Usuário:"

E informo "behave" no campo "Senha:"




26

4.5. Parametrizando os cenários

Parâmetros devem ser utilizados nos cenários quando os dados utilizados nos testes não forem constantes. A

sintaxe de um parâmetro é "{nome_do_parametro}".

Cenário: Acessar o sistema com usuário "{usuario}" e senha "{senha}"


Quando informo "{usuario}" no campo "Usuário:"

E informo "{senha}" no campo "Senha:"



4.6. Reusando os cenários

Para que o reúso ocorra é necessário, primeiramente, utilizar parâmetros no nome do cenário. Isto irá prevenir que

o cenário seja "executado" pelo framework, mas, deste forma, ele poderá ser referenciado por outros cenários,

diminuindo a quantidade de linhas escritas em todo o projeto de teste.

Cenário: Acessar o sistema com usuário "{usuario}" e senha "{senha}"


Quando informo "{usuario}" no campo "Usuário:"

E informo "{senha}" no campo "Senha:"



Cenário: Sair do sistema

Dado que vou para a página "Tela Principal"

Quando clico em "Sair"

Então será exibido "Usuário:"

E será exibido "Senha:"

Cenário: Teste com dados "{usuario}" e senha "{senha}"

Acessar o sistema com usuário "{usuario}" e senha "{senha}"

Sair do sistema

4.7. Reusando os cenários em outras histórias

Para que o reúso de cenários ocorra em outras histórias é necessário, primeiramente, que a história seja adicionada

no contexto do teste que será executado.

BehaveContext eng = BehaveContext.getInstance();

// Adiciona histórias que serão executadas

eng.addStories("/stories/acesso.story");

eng.addStories("/stories/estou-com-sorte.story");

eng.addStories("/stories/pesquisa-simples.story");

// Roda as histórias incluída

eng.run();

Plugin do JBehave para Eclipse

27

Assim a chamada ao cenário se dar através da utilização do título do cenário pretendido.

Em /stories/acesso.story:

Cenário: Acesso ao "{sistema}"

Dado que vou para a tela "Tela de Busca"

Então será exibido "{sistema}"

Em /stories/estou-com-sorte.story:

Cenário: Utilização da funcionalidade estou com sorte

Acesso ao "Google"

Quando clico em "Estou com sorte"

Então será exibido "Google"

Uma outra possibilidade seria adicionar a história somente para reúso.

BehaveContext eng = BehaveContext.getInstance();

// Adiciona história somente para reuso de cenários

// Cenários que não reutilizados não serão executados

eng.addStoriesReuse("/stories/acesso.story");

// Adiciona histórias que serão executadas

eng.addStories("/stories/estou-com-sorte.story");

eng.addStories("/stories/pesquisa-simples.story");

// Roda as histórias incluída

eng.run();

Desta maneira os cenários que não são parametrizados contidos nas histórias passadas no método

"addStoriesReuse" não serão executados. Caso que não ocorre quando utilizado o método "addStories", onde todos

os cenários que não são parametrizados serão executados.

4.8. Plugin do JBehave para Eclipse

Funcionalidades:

• Passos com coloração (Syntax highlighting)

• Link entre os passos escritos nas histórias e o método dentro do código Java

• Auto completar nos passos criados no código java, inclusive os passos comuns


28

• Validação dos passos, detectando se existem passos não mapeados por exemplo

Requisitos:

O Plugin já foi testado nas versões Indigo (3.7) e Juno (4.2) do Eclipse.

Instalação usando o Eclipse:

• 1. Clique em Help > Install New Software...

• 2. Adicione uma nova localização de site: http://jbehave.org/reference/eclipse/updates/

• 3. Após adicionar a localização procure pelo plugin JBehave Eclipse e siga o procedimento padrão para instalação

de plugins

Configuração:

• Após a instalação acesse o menu do Eclipse, Window > Preferences > JBehave -> Project Settings e selecione

em Story Language como pt.

• Com esta configuração será possível ver as histórias escritas em português com as marcações coloridas e o auto

completar funcionará normalmente.

29

Configurações do BehaveTodos os módulos do Demoseille Behave possuem configurações específicas (Parsers, Runners e Integrations),

boa parte delas possui um valor padrão que pode ser alterado no projeto.

Dica

Também é possível alterar estas configurações utilizando o parâmetro-D para a chamada da

máquina virtual Java. Por exemplo: -Dbehave.integration.alm.enabled=true

5.1. Configurações do Parser

• behave.parser.language: propriedade que seleciona a linguagem que o parser trabalhará, o padrão é pt.

• behave.parser.identification.scenario.pattern: propriedade define a expressão regular que identificará um início

de cenário no arquivo de história. O Padrão é ^(\\s)*(CEN\u00C1RIO|Cen\u00E1rio|cen\u00E1rio)\:(.*)

• behave.parser.story.timeout: Define o tempo máximo em minutos para execução das histórias.

• behave.parser.prefixes.bdd.pattern: propriedade define a expressão regular que identificará um início de cada

passo no arquivo de história. O Padrão é ^(\\s)*(DADO |QUANDO |ENT\u00C3O |E |MAS |Dado |Quando |Ent

\u00E3o |Mas |dado |quando |ent\u00E3o |e |mas)(.*)

• behave.parser.story.extension.original: propriedade define a extensão do arquivo original que será lido, o padrão

é bdd no core, mas no caso do JBehave o padrão é story.

• behave.parser.story.extension.converted: propriedade define a extensão do arquivo gerado após o pré-

processamento do framework, o padrão é story no core, mas no caso do JBehave o padrão é storyConverted.

• behave.parser.commonssteps.enabled: propriedade que habilita os passos comuns utilizados pelos parsers. O

padrão é ativado.

• behave.parser.beforeaftersteps.enabled: propriedade que habilita os passos anteriores e posteriores às

execuções das histórias. No caso do runner WebDriver ele conduz o navegador nestes passos. O padrão é

ativado.

• behave.parser.delayBetweenSteps: propriedade que coloca uma espera entre a execução dos passos. Se for 0

(Zero) ele estará desabilitado. O padrão é 0 (Zero).

• behave.parser.screenshot.enabled propriedade que faz habilita ou desabilita a captura de tela quando ocorre um

erro. O padrão é true.

• behave.parser.coloredconsole.enabled propriedade para habilitar a saída colorida no console. O padrão é false.

• behave.parser.erroDuplicateScenarios propriedade que faz com que o parser verifique se existem cenários

duplicados na execução. O padrão é true.

5.2. Configurações do Runner

• behave.runner.screen.maxWait : Tempo máximo de espera em uma ação na tela. O valor padrão é 10000

milissegundos.

Capítulo 5. Configurações do ...

30

• behave.runner.screen.minWait : Tempo mínimo de espera entre as ações da tela, contudo esta propriedade é

utilizada somente nos casos em que o framework precisa tentar mais de uma vez localizar e executar uma ação

em um elemento. O valor padrão é 100 milissegundos .

• behave.runner.proxy.url : propriedade que, quando informada, ativará o uso de proxy no navegador. O valor

padrão da url do proxy é vazio.

• behave.runner.screen.type : Opções do WebDriver: MozillaFirefox, InternetExplorer, GoogleChrome. No caso do

IE e Chrome são necessárias configurações adicionais. O valor padrão é MozillaFirefox .

• behave.runner.screen.remote.name : Para testes remotos, esta propriedade informa qual navegador será

utilizado. O valor padrão é vazio.

• behave.runner.screen.remote.url : Para testes remotos, esta propriedade informa a URL na qual o Selenium

Server encontra-se, o valor padrão é vazio.

• behave.runner.screen.commandLineOptions : permite passar os parâmetros de inicialização do navegador,

substituindo todos os fornecidos pelo framework. Por enquanto somente existe implementação para o Google

Chrome. O valor padrão é vazio.

• behave.runner.screen.driverPath : Localização do driver que faz ligação entre o navegador e o webdriver. O valor

padrão é vazio.

• behave.runner.profile.enabled : propriedade que ativa ou desativa o uso de profile no navegador. O valor padrão

é desabilitado.

• behave.runner.screen.profilePath : Localização do profile. O valor padrão é vazio .

• behave.runner.app.mainClass : Nome de domínio qualificado da classe principal da aplicação sobre testes. O

valor padrão é vazio.

• behave.runner.proxy.enabled : habilita a utilização do proxy no runner (Navegador). O valor padrão é desabilitado.

• behave.runner.proxy.url : URL do proxy a ser utilizado quando a opção do Proxy está habilitada. O valor padrão

é vazio.

• behave.runner.screen.binaryPath : localização do binário do navegador quando se quer utilizar uma versão

específica (ex: //home//USER//firefox//firefox-bin). O valor padrão é desabilitado.

• behave.runner.catchUIException : exceções a serem capturadas em caso de erro genérico

(StaleElementReferenceException). O valor padrão é org.openqa.selenium.StaleElementReferenceException.

• behave.runner.window.maximize.enabled : ativa o uso maximizado da janela do navegador, o valor padrão é false.

• behave.runner.screen.screenshot.zoomout : níves de zoom out que o framework realizará antes de capturar a

tela, o valor padrão é 0.

• behave.runner.legacyRunner : Habilita ou desabilita o modo de execução legado para retrocompatibilidade. O

valor padrão é true.

• behave.runner.legacyRunner : Ativa o o log (DEBUG) de mensagems de estatísticas de execução. O valor padrão

é false.

5.3. Configurações do Integration

• behave.integration.alm.enabled : propriedade que habilita/desabilita a funcionalidade de integração com a ALM.

O valor padrão é desabilitado .

Configurações do Integration - Autenticator ALM

31

• behave.integration.alm.url.security : Campo obrigatório para integração com a ALM. Endereço completo do

caminho para autenticação na ALM. O valor padrão é vazio .

• behave.integration.alm.url.services : Campo obrigatório para integração com a ALM. Endereço completo do

caminho para os serviços REST. O valor padrão é vazio .

• behave.integration.alm.projectArea : Campo obrigatório para integração com a ALM. Alias da área de projeto.

Tomar cuidado com áreas renomeadas, pois o Alias não é alterado, o valor padrão é vazio .

• behave.integration.alm.testPlanId : Campo obrigatório para integração com a ALM. Id do plano de testes que

pertence a área de projeto. O valor padrão é vazio .

• behave.integration.authenticator.host : Endereço (IP) do Autenticator. O valor padrão é localhost .

• behave.integration.authenticator.port : Porta utilizada para comunicação com o Autenticator. O valor padrão é

9990 .

• behave.integration.alm.autoAssociateTestCaseInPlan : propriedade que habilita/desabilita a a associação

automática de Casos de Teste ao Plano de Teste do RQM. O valor padrão é true .

• behave.integration.alm.categoryTipoExecucao : propriedade do valor informado no "Tipo de Execução" quando

um Caso de Teste é enviado para a ALM. O valor padrão é Automatizado .

5.4. Configurações do Integration - Autenticator ALM

Atenção

O Autenticator é necessário para que a integração com a ALM funcione

corretamente, não sendo possível fazer a integração sem esse utilitário. Caso

o Autenticator não esteja disponível a seguinte mensagem será exibida na

exceção lançada: br.gov.frameworkdemoiselle.behave.exception.BehaveException: Autenticador

inacessível. Verifique se o processo foi iniciado

1. Instalação no Projeto

Para fazer uso do módulo de integração basta acrescentar a dependência no pom.xml do projeto.

<dependency>

<groupId>br.gov.frameworkdemoiselle.component.behave</groupId>

<artifactId>demoiselle-behave-integration-alm</artifactId>

<version>1.x.x</version>

<scope>test</scope>

</dependency>

2. Motivações

• Todas as chamadas Rest ao RQM necessitam de um usuário e senha válidos para a plataforma Jazz.

• Por segurança não recomendamos armazenar de forma persistente estas informações.

• O componente “demoiselle-behave-integration-alm” provê uma forma segura de armazenar o usuário e senha

do testador.

Capítulo 5. Configurações do ...

32

• O armazenamento é realizado em memória de forma criptografada e podendo ser acessado apenas localmente

na estação do testador durante a execução dos testes.

3. Utilização

• Para iniciar o serviço, obtenha o autenticador demoiselle-behave-integration-

alm-1.5.0.jar [http://demoiselle.sourceforge.net/repository/release/br/gov/frameworkdemoiselle/component/

behave/demoiselle-behave-integration-alm/1.5.0/demoiselle-behave-integration-alm-1.5.0.jar] e execute-o com o

seguinte comando:

java -jar demoiselle-behave-integration-alm-[versao].java

• Parâmetros:

-p [porta] -o [ip-de-origem]

http://demoiselle.sourceforge.net/repository/release/br/gov/frameworkdemoiselle/component/behave/demoiselle-behave-integration-alm/1.5.0/demoiselle-behave-integration-alm-1.5.0.jar




33

Escopo de Histórias e PassosNeste capítulo detalharemos como o Dbehave tratava originalmente as histórias que compunham um cenário e

como elas serão tratadas a partir da nova versão.

6.1. DBehave Legado

Ao trabalhar com o framework, lidamos basicamente com 3 itens, a seguir:

• Histórias - context.addStories();

• Histórias de reuso - context.addStoriesReuse();

• Passos personalizados - context.addSteps().

Ao executar somente um método de uma classe nenhum problema ocorria, porém ao executar um conjunto de

classes ao mesmo tempo, o DBehave apresentava um comportamento diferente para cada um dos itens listados.

• Histórias - Eram mantidas em memória durante toda a execução do conjunto de testes;

• Histórias de reuso - Eram removidas após a execução de cada método;

• Passos personalizados -Eram removidos após a execução de cada método.

Este comportamento acarretava em um problema no design dos testes. Ao executar várias classes de teste,

tínhamos sempre que em cada método redefinir os passos e reusos, porém não podíamos redefinir as histórias.

Manter todas as histórias em memória também não é uma boa solução do ponto de vista computacional, pois com

testes extensos, a tendência é que o framework fique sobrecarregado.

Outro ponto importante que merece destaque é que a execução do JUnit é aleatória, ou seja, a cada execução uma

das classes do conjunto é sorteada e essa aleatoriedade vai até o ponto dos métodos.

Como o framework mantinha as histórias em memória, ao programar cada método de teste, para que ficassem

corretamente encapsulados, tínhamos que em cada um definir todas as histórias que o compunham. Porém como

a história já havia sido adicionada previamente o framework apresentava o erro de duplicidade de um .story.

Desta forma ou definíamos que um conjunto de testes sempre iria executar em conjunto ou individualmente, pois o

comportamento errático da ferramenta não permitia um bom design de projeto.

6.2. DBehave com Suporte à Escopos

Para solucionar o problema apresentado no tópico anterior, definimos um conjunto de escopos para cada um dos

elementos, permitindo assim que o desenvolvedor defina sua melhor forma de trabalho.

• Global - Tudo que for adicionado com o escopo global será mantido em memória durante toda a execução da

ferramenta;

• Classes - O que for adicionado com o escopo de classes será mantido em memória durante toda execução da

classe Java;

• Método - Os elementos deste escopo são mantidos apenas durante a execução do método da classe Java.

Para manter a retrocompatibilidade com os projetos anteriores, a nova versão do DBehave vem automaticamente

preparada para o modo Legado.

Capítulo 6. Escopo de Históri...

34

É necessário no behave.properties alterarmos a configuração behave.runner.legacyRunner=true para false. Desta

forma habilitamos a ferramenta para trabalhar com o novo modo de escopos.

A nova API para cada elemento segue:

• Global - context.addStepsGlobal(), context.addStoriesGlobal(), context.addStoriesReuseGlobal();

• Classes - context.addStepsClass(), context.addStoriesClass(), context.addStoriesReuseClass();

• Método - context.addStepsMethod(), context.addStoriesMethod(), context.addStoriesReuseMethod().

Lembrando que os modos de execução da ferramenta são exclusivos, ao utilizar a nova versão, os comandos

context.addSteps(),context.addStories() e context.addStoriesReuse() não serão permitidos. O mesmo acontece ao

utilizar o modo legado e a nova API.

Dica

Importante: ao utilizar o escopo de classes, a sua classe deverá obrigatoriamente estender a

classe ClassScopeManager. Caso não estenda, o framework apresentará um erro mostrando a

obrigatoriedade do mesmo.

35

Testando aplicações DesktopO Framework Demoiselle Behave possui um Runner específico para testes de aplicações Desktop (Swing). Neste

capítulo este assunto será abordado.

7.1. Iniciando um projeto utilizando o Arquétipo

(Modelo de Projeto)

Na criação do projeto é possível selecionar o arquétipo jbehave-fest-archetype para ter um início rápido de um

projeto para automação de testes Desktop (Swing).

7.2. Iniciando um projeto utilizando um projeto

existente (Projeto WebDriver)

Para transformar um projeto existente em um projeto de testes funcionais Desktop basta alterar o runner e fazer as

configurações necessárias. Alterar a dependência do runner.

<dependency>


<artifactId>demoiselle-behave-runner-fest</artifactId>

<version>1.x.x</version>

<scope>test</scope>

</dependency>

7.3. Configurações Desktop

Todas as configurações já citadas anteriormente e que são pertinentes ao Desktop também podem ser utilizadas.

Abaixo estão as configurações específicas para Desktop:

• Adicionar o projeto no classpath do projeto de testes;

• Adicionar a configuração behave.runner.app.mainClass nas propriedades apontando para a class que inicia o

projeto Desktop.

7.4. Mapeamentos

O runner Desktop utiliza 3 tipos de localizadores, conforme abaixo:

• Label: Seleciona o objeto de tela que possua o text visível;

• Name: Seleciona o objeto de tela que tenha o identificador selecionado pelo desenvolvedor;

• ClassName: Seleciona o objeto de tela que tenha a classe definida (JPanel, JButton...).

Adicionalmente a estes localizadores é possível selecionar o índice que o objeto está utilizando, tal como a anotação

@ElementIndex, no exemplo a seguir:

@ElementMap(name = "Nome do Elemento na História", locatorType = ElementLocatorType.ClassName,

locator = "JTextField")

Capítulo 7. Testando aplicaçõ...

36

@ElementIndex(index = 1)

private TextField atributo;

Por padrão o índice do objeto é 0 (Zero).

37

Configurações dos Testes

8.1. Configuração de Passos (Steps)

Configuração de um pacote para carga das subclasses de Step, incluindo um filtro das classes que devem ser

excluídas desta varredura; Quando um contexto for inicializado, não será mais necessário instanciar cada uma das

subclasses de Step a serem utilizadas:

context = BehaveContext.getInstance();

context.addSteps(new PrimeiraSteps());

context.addSteps(new SegundaSteps());

context.addSteps(new TerceiraSteps());

context.addSteps(new QuartaSteps());

Bastando para tanto:

context.setStepsPackage("pacote.onde.estao.as.subclasses.da.inferface.step");

Ainda é possível utilizar um segundo parâmetro para filtrar as classes que não devem ser instanciadas, através

de uma expressão regular:

context.setStepsPackage("pacote.onde.estao.as.subclasses.da.inferface.step", "((Primeira)|

(Terceira))");

Ou, ainda, através da listagem das mesmas:

context.setStepsPackage("pacote.onde.estao.as.subclasses.da.inferface.step",

PrimeiraSteps.class, TerceiraSteps.class);

8.2. Configuração de Histórias e Cenários

Filtro de histórias/cenários a serem executados, permitindo que um desenvolvedor foque em apenas uma estória

ou cenário; Dadas as histórias:

!-- /stories/primeira.story

Funcionalidade: Primeira

Cenário: Primeiro da primeira

Dado que contexto

Quando evento

Então resultado

Cenário: Segunda da primeira

Dado que contexto

Capítulo 8. Configurações dos...

38

Quando evento

Então resultado

!-- /stories/segunda.story

Funcionalidade: Segunda

Cenário: Primeiro da segunda

Dado que contexto

Quando evento

Então resultado

Cenário: Segundo da segunda

Dado que contexto

Quando evento

Então resultado

Quando da execução das histórias/cenários:

context.run("/stories");

Agora é possível, filtrar quais histórias:

context.run("/stories", Filter.story("Primeira"));

Ou, quais cenários:

context.run("/stories", Filter.scenario("Segundo da segunda"));

Sendo que o último, pode ser informado usando apenas a expressão regular:

context.run("/stories", "Segundo da segunda");

39

Execução de TestesEste capítulo apresenta recursos avançados para execução de testes com o Demoiselle Behave, que podem auxiliar

a montagem de um ambiente para execução de testes funcionais.

9.1. Execução com Ghost Driver (Funcionalidade

Experimental)

Ghost Driver é um WebDriver remoto que usa PhantomJS como back-end. É uma implementação JavaScript do

Protocolo do WebDriver para PhantomJS a fim de rodar testes headless em Selenium.

Para ativá-lo informe o driver GhostDriver nas propriedades do dbehave (behave.properties):

behave.runner.screen.type=GhostDriver

Também é necessário informar o local do binário do PhantmJS na propriedade behave.runner.screen.driverPath:

behave.runner.screen.driverPath=/usr/lib/node_modules/phantomjs/lib/phantom/bin/phantomjs

Outro caminho possível é:

behave.runner.screen.driverPath=/usr/local/bin/phantomjs

Dica

O Phantomjs pode ser instalado pelo comando sudo npm install -g phantomjs.

9.2. Execução Paralela

A execução de testes de forma paralela pode ser uma alternativa para reduzir o tempo de execução das baterias.

Neste caso observe que esta abordagem aumenta a necessidade de processamento da máquina de ativação dos

testes. Além disso se deve garantir a independência entre os testes para evitar falsos positivos.

O Demoiselle Behave recomenda a utilização do maven-surefire-plugin que gerencia a execução do teste conforme

os seguintes parâmetros:

• forkCount : Determina o número máximo de threads que deverão ser paralelizadas;

• threadCount : Número máximo de threads por jvm;

• reuseForks=false : Garante a execução das threads em JVMs isoladas. Esta configuração evita que dados

utilizados por uma thread sejam afetados por outras.

Capítulo 9. Execução de Testes

40

• parallel=classes : Define a estratégia de paralelização. Neste caso, cada classe de teste do JUnit será instanciada

por uma thread até atingir o número máximo de threads (forkCount). É recomendado utilizar o nível de classe,

pois havendo a necessidade de dependência entre os testes, esta pode ser realizada dentro da classe JUnit.

Segue abaixo o exemplo para configuração do plugin no arquivo pom.xml do projeto:

<build>

<plugins>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-surefire-plugin</artifactId>

<version>2.16</version>

<configuration>

<forkCount>3</forkCount>

<threadCount>1</threadCount>

<reuseForks>false</reuseForks>

<parallel>classes</parallel>

</configuration>

</plugin>

</plugins>

</build>

Para executar seu teste de forma paralela acione o menu “Run as → Maven Test” do eclipse ou no terminal execute

“mvn test”.

9.3. Modo Background

A execução de testes em modo background é um recurso importante quando se deseja criar um ambiente dedicado

para execução de testes. Normalmente estes ambientes não possuem interface gráfica que impedem o acionamento

de navegadores.

Outra situação comum acontece quando o testador executa os testes em sua estação de trabalho e necessita utilizar

outros programas que concorrerão com sua tela, devido a utilização de navegadores.

Para ambientes Linux, que possuem ferramentas para emulação de tela, o Demoiselle Behave recomenda a

utilização da ferramenta Xvfb.

Instalação:

apt-get install xvfb

Execução do Xvfb:

Xvfb :2 -screen 0 1024x768x24

É possível instanciar vários processos Xvfb por meio de identificadores diferentes. No exemplo acima foi definido

com o identificador “2”.

Para executar um aplicativo que utiliza a interface gráfica acione o comando DISPLAY:

Integração Contínua

41

DISPLAY=:2 firefox

Para rodar um teste no Xvfb, basta rodar:

DISPLAY=:2 mvn test

Para visualizar processos rodando no Xvfb use o x11vnc (apt-get install x11vnc) que instanciará o serviço vnc para

um identificador Xvfb específico:

x11vnc -display :2

9.4. Integração Contínua

Para execução de testes funcionais em modo background, sob um ambiente de integração contínua é necessária a

instalação de plugins que permitam gerenciar o Xvfb. O Jenkins possui o plugin: https://wiki.jenkins-ci.org/display/

JENKINS/Xvfb+Plugin [https://wiki.jenkins-ci.org/display/JENKINS/Xvfb+Plugin] que permite realizar este controle.

Xvfb Plugin

Após instalar o plugin configure-o pelo menu “Gerenciar o Jenkins → Configurar o sistema” na seção Xvfb

installation, informe um nome “padrão” e a pasta em que o executável do Xvfb foi instalado “/usr/bin”.

Configuração do Sistema

Para cada projeto Jenkins configure na seção “Ambiente de Construção” a instalação, seu timeout, as dimensões

da tela e seu display:

https://wiki.jenkins-ci.org/display/JENKINS/Xvfb+Plugin




42

Configuração do Projeto

Ao executar seu projeto, o Jenkins iniciará o Xvfb antes da construção da build e finalizará o processo ao final da

build:

Console

9.5. Testes Remotos

A execução de testes remotos, na qual o navegador rodará numa estação diferente da estação originadora dos

testes, é realizada por meio do Selenium Server. Este roteiro auxilia a criação rápida deste ambiente.

Instalação do Selenium Server

• Download: Obtenha o Selenium Server no site http://code.google.com/p/selenium/ [http://code.google.com/

p/selenium/] ou direto na área de donwload do DBehave selenium-server-standalone-2.37.0.jar [https://

www.dropbox.com/s/o1bo9gb8b6dqv1e/selenium-server-standalone-2.37.0.jar]. Recomendamos a versão 2.37.0

ou superior.

• Iniciar Serviço: Rode o Selenium Server na estação que executará o navegador:

java -jar selenium-server-standalone-2.37.0.jar

Configuração do Projeto

• demoiselle.properties: Abra o arquivo demoiselle.properties do seu projeto e configure as seguintes propriedades:

http://code.google.com/p/selenium/



https://www.dropbox.com/s/o1bo9gb8b6dqv1e/selenium-server-standalone-2.37.0.jar



Relatórios JBehave

43

//Altera o driver para o modo remoto

behave.runner.screen.type=RemoteWeb

//informa o navegador. Opções disponíveis: firefox, chrome, internetExplorer, safari, htmlUnit

behave.runner.screen.remote.name=firefox

//informa a url na qual encontra-se o Selenium Server

behave.runner.screen.remote.url=http://127.0.0.1:4444/wd/hub

• Navegadores: Caso necessite executar seu teste em um navegador diferente do Firefox, além de configurar

a propriedade “behave.runner.screen.remote.name”, inicie o Selenium Server informando o caminho do driver

específico ao seu navegador:

java -jar selenium-server-standalone-2.37.0.jar -Dwebdriver.chrome.driver=/path/chromedriver

9.6. Relatórios JBehave

Ao final da execução dos testes automatizados são gerados relatórios na pasta target/jbehave/view. O arquivo

principal é o index.html, passível de abertura com qualquer navegador. Ao abrir o arquivo deve-se clicar em "Story

Reports" para ter acesso ao relatório da execução.

Relatório Geral da Execução

Para acessar os detalhes de cada história existe um link na última coluna (view), na direita da tabela, como mostra

a imagem abaixo:


44

Link para detalhes da história

Após clicar no link "html" da tela de visão geral, a seguinte tela será exibida:

Detalhamento da História

Na tela acima é apresentado o detalhamento dos cenários contidos na história.

Relatórios JBehave

45

Cenário com Erro (Desktop)

Caso algum erro venha a ocorrer, este será apresentado junto com um print screen da tela (Desktop e Web).

46

47

Conjunto de Dados10.1. Conceito

Este capítulo apresenta a funcionalidade de Conjunto de Dados (Dataset), que permite a criação de grandes

conjuntos de dados em formato XML para utilização nas histórias. O exemplo de teste utilizado tem como objetivo

cadastrar diversas obras em um cadastro, para tanto deverão ser informados vários dados de cadastro.

10.2. Criação do XML de Dados

O primeiro passo para a utilização do Conjunto de Dados é a criação de um XML contendo os dados que serão

utilizados nas histórias. A estrutura deve ser parecida com a do exemplo abaixo, realtivo ao arquivo obras.xml:

<DataSet>

<dataRecords>

<DataRecord id="Parque olímpico">

<dataItems>

<DataItem key="Nome Obra" value="Parque Olímpico" />

<DataItem key="Valor" value="250000000" />

<DataItem key="Prazo" value="01/05/2015" />

</dataItems>

</DataRecord>

<DataRecord id="Vila olímpica">

<dataItems>

<DataItem key="Nome Obra" value="Vila Olímpica e Paraolímpica" />

<DataItem key="Valor" value="150000000" />

<DataItem key="Prazo" value="01/07/2015" />

</dataItems>

</DataRecord>

</dataRecords>

</DataSet>

10.3. Configuração do Data Provider

Para utilizar o arquivo de dados XML ele deve ser informado antes de rodar o teste como no exemplo abaixo,

relativo ao arquivo ObrasTest.java.

public class ObrasTest {

private BehaveContext eng = BehaveContext.getInstance();

private static DatasetProvider datasetProvider = (DatasetProvider)

InjectionManager.getInstance().getInstanceDependecy(DatasetProvider.class);

public ObrasTest() {

datasetProvider.load("obras","/datasets/obras.xml");

}

@Test

public void testAllObras() throws Throwable {

eng.addStories("/stories/obra.story");

eng.run();

}

Capítulo 10. Conjunto de Dados

48

}

10.4. Criação da História

Na criação da história (obra.story) foram adicionados dois cenários, um para reúso recebendo o parâmetro obra,

e outro que chamará duas vezes o cenário de reúso, com parâmetros diferentes. Abaixo está a história que será

utilizada duas vezes.

Cenário: adiciono a obra "{obra}"

Dado que estou na tela "Tela Principal"

Então vou para a tela "Lista de Obras"

Quando clico em "Adicionar Obra"

Então será exibido "Cadastro"

Quando seleciono "{obra}" do conjunto de dados "obras"

Quando informo o valor do campo "Nome Obra"

Quando informo o valor do campo "Valor"

Quando informo o valor do campo "Prazo"

Quando clico em "Inserir"

Vale notar que o passo Quando seleciono "{obra}" do conjunto de dados "obras" seleciona o registro criado no XML

anteriormente, que é utilizado nos 3 passos seguintes.

No exemplo abaixo está sendo chamado duas vezes o cenário de reuso criado no exemplo acima. É importante citar

que ele é chamado utilizando dois Data Records diferentes, primeiro o "Parque olímpico" e depois a "Vila olímpica".

Cenário: Adição de obras armazenadas no dataset

Dado que acessei o sistema

Quando adiciono a obra "Parque olímpico"

Então será exibido "Nome Obra"

Quando adiciono a obra "Vila olímpica"

Então será exibido "Nome Obra"

49

Testes de Regressão de LayoutNeste capítulo será apresentada a funcionalidade que permite a comparação de layout entre navegadores diferentes

a partir de histórias desenvolvidas em projetos do dbehave.

Atenção

Esta funcionalidade está disponível a partir da versão 1.5.0 do dbehave.

11.1. Conceito

A ideia principal da funcionalidade é permitir a equipe do projeto ter uma visibilidade, por meio de imagens e

números, das diferenças de design entre os diversos navegadores que são, ou serão, suportados pelo sistema.

O processo de navegação no sistema deve ser feito por meio das histórias do dbehave, que em alguns casos já

existem, e a partir de imagens capturadas durante o processo seja gerado um relatório ao final do teste, comparando

os navegadores selecionados com um que deve ser o navegador de referência.

11.2. Pré Requisitos

Para que o teste de regressão de layout funcione corretamente são necessárias algumas tecnologias durante o

processo, seguem elas.

11.2.1. Java

É necessário ter o Java (JDK) instalado para que o processo funcione, normalmente as máquinas que já rodam

o dbehave já possuem a versão necessária. Para verificar se a JDK está instalada corretamente rode o seguinte

comando:

java -version

A saída do console deverá ser parecida com esta:

java version "1.6.0_35"

OpenJDK Runtime Environment (IcedTea6 1.13.7) (6b35-1.13.7-1ubuntu0.12.04.2)

OpenJDK Server VM (build 23.25-b01, mixed mode)

11.2.2. Image Magick

Para que o processo de comparação dos layouts funcione corretamente é necessário que a biclioteca Image Magick

(http://www.imagemagick.org) seja instalada. A instalação desta biblioteca em muitas distribuições Linux, como a

Ubuntu 12.04, pode ser feita através do seguinte comando:

sudo apt-get install imagemagick

Capítulo 11. Testes de Regres...

50

Após a instalação acesse o Promp/Terminar do computador que irá rodar os testes e rode o seguinte comando:

compare --version

E o resultado deverá ser algo como o seguinte texto:

Version: ImageMagick 6.9.0-0 Q16 i686 2014-11-24 http://www.imagemagick.org

Copyright: Copyright (C) 1999-2014 ImageMagick Studio LLC

Features: DPC OpenMP

Delegates (built-in): png x zlib

11.2.3. Projeto dbehave

O teste de regressão tem como pré requisito inicial um projeto dbehave já criado, caso ainda não tenha criado um

basta seguir o Roteiro Rápido [http://demoiselle.sourceforge.net/docs/components/behave/reference/lastversion/

html/behave-quickstart.html] do manual do dbehave.

11.2.4. Maven

Para que o teste rode corretamente é necessário que a máquina tenha instalado o Maven, para saber se ele esta

funcionando corretamente rode o seguinte comando no prompt/terminal:

mvn --version

A saída do console deverá ser algo parecido com o seguinte:

Apache Maven 2.2.1 (rdebian-8)

Java version: 1.6.0_33

Java home: /usr/lib/jvm/java-6-serpro-1.6.0.33/jre

Default locale: pt_BR, platform encoding: UTF-8

OS name: "linux" version: "3.2.0-58-generic-pae" arch: "i386" Family: "unix"

11.3. Configuração do Projeto dbehave

Esta sessão descreve como o projeto dbehave deve ser configurado para que o teste de regressão rode.

11.3.1. Configurações Básicas do pom.xml

Esta funcionalidade possui basicamente 2 inclusões no pom.xml:

• 1. Passos personalizados para capturar as telas a serem comparadas

• 2. Plugin maven que faz as comparações e gera o relatório

Para adicionar os passos personalizados basta adicionar uma nova dependência ao pom.xml na tag dependencies

como segue abaixo:

http://demoiselle.sourceforge.net/docs/components/behave/reference/lastversion/html/behave-quickstart.html



Configurações do behave.properties

51

<dependency>


<artifactId>demoiselle-behave-regression-step</artifactId>

<scope>test</scope>

</dependency>

E a outra configuração é a inclusão do plugin maven dentro da tag build/plugins como abaixo:

<build>

<plugins>

<plugin>


<artifactId>demoiselle-behave-regression-report</artifactId>

<version>1.5.0</version>

<executions>

<execution>

<phase>test</phase>

<goals>

<goal>regression</goal>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</build>

11.3.2. Configurações do behave.properties

Para que as capturas de tela e relatório seja gerado são necessárias algumas configurações no behave.properties

• Configurações Gerais

Propriedade que ativa a funcionalidade de regressão no dbehave.

behave.regression.enabled=true

Propriedade utilizada pelo método RegressionConfig.getTypes() para fazer o laço de repetição da execução dos

testes e geração do relatório. São os navegadores que serão utilizados.

behave.regression.types=linux1204_Firefox30,linux1204_Chrome33,windows7_IE9,windows7_Chrome35

Propriedade que define o navegador que será utilizado como referência para as comparações:

behave.regression.defaultType=linux1204_Firefox

• Configuração dos Navegadores


52

Para cada navegador listado na propriedade behave.regression.types deverá existir um conjunto de propriedades

que são definidas com o seguinte padrão:

behave.regression.NOME_DO_NAVEGADOR.runner.PROPRIEDADE

Dica

Utilize um nome legível e que determine o Sistema Operacional e Navegador e suas respectivas

versões no NOME_DO_NAVEGADOR das propriedades, pois é este nome que será utilizado

nos relatórios de comparação.

Abaixo estão as possíveis propriedades a serem usadas na configuração de cada navegador:

• ...runner.screen.maxWait

• ...runner.screen.minWait

• ...runner.proxy.enabled

• ...runner.proxy.url

• ...runner.screen.driverPath

• ...runner.profile.enabled

• ...runner.screen.remote.url

• ...runner.screen.remote.name

• ...runner.screen.profilePath

• ...runner.screen.binaryPath

• ...runner.screen.type

• ...runner.catchUIException

• ...runner.window.maximize.enabled

Exemplo de configuração de navegadores:

// Navegador Firefox na própria máquina

behave.regression.linux1204_Firefox30.runner.screen.type=MozillaFirefox

behave.regression.linux1204_Firefox30.runner.window.maximize.enabled=true

// Navegador Chrome na própria máquina

behave.regression.linux1204_Chrome33.runner.screen.type=GoogleChrome

behave.regression.linux1204_Chrome33.runner.window.maximize.enabled=true

behave.regression.linux1204_Chrome33.runner.screen.driverPath=//path//do//driver//

chromedriver

// Navegador Internet Explorer 9 em uma máquina remota

behave.regression.windows7_IE9.runner.screen.type=RemoteWeb

behave.regression.windows7_IE9.runner.window.maximize.enabled=true

Repositório Local de Imagens

53

behave.regression.windows7_IE9.runner.screen.remote.name=internetExplorer

behave.regression.windows7_IE9.runner.screen.remote.url=http://X.X.X.X:4444/wd/hub

// Navegador Chrome em uma máquina remota

behave.regression.windows7_Chrome35.runner.screen.type=RemoteWeb

behave.regression.windows7_Chrome35.runner.window.maximize.enabled=true

behave.regression.windows7_Chrome35.runner.screen.remote.name=chrome

behave.regression.windows7_Chrome35.runner.screen.remote.url=http://X.X.X.X:4444/wd/hub

11.3.3. Repositório Local de Imagens

Para o repositório local ele irá usar o diretório home do usuário como padrão, por exemplo, no Linux ele irá ficar

em /home/NOME_DO_USUARIO/.dbehave/.

A configuração é bem simples, basta selecionar a seguinte propriedade:

behave.regression.type=local

11.4. Pontos de Comparação

Para que as novas frases de captura funcionem é necessário adicionar os passos ao dbehave por meio do seguinte

comando:

BehaveContext.getInstance().addSteps(new RegressionSteps());

Para que as telas sejam capturadas basta utilizar uma das seguinte frases:

Quando tiro um print screen

Quando tiro um print screen com o nome "NOME DA CAPTURA QUE APARECERÁ NO RELATÓRIO"

11.5. Rodando o Teste de Regressão

Mostrar o comando maven e a saída do console e o relatório. O resultado final será criado na pasta /target/dbehave

do seu projeto dbehave. É recomendado que sejam criados novos métodos JUnit com o seguinte código:

@Test // Anotação JUnit

public void testRegressaoLayout() throws Throwable {

// Laço de repetição para testar com todos os navagedores

for (String browser : RegressionConfig.getTypes()) {

RegressionConfig.setCurrentType(browser); // Seleciona o navegador atual

eng.addStoriesReuse("/stories/XXXX.story"); // Histórias de reuso

eng.addStories("/stories/XXXXX.story"); // Histórias que irão rodar

eng.addSteps(new MySteps()); // Passos customizados

eng.addSteps(new RegressionSteps()); // Passos de captura


54

// Roda o teste para o navegador atual selecionado no setCurrentType

eng.run();

}

}

11.6. Relatório Gerado

Atenção

O relatório só será gerado se os testes funcionais passarem e quando for executado via maven

(mvn package), pois o relatório é gerado por meio de um plugin.

O relatório final será criado na pasta /target/dbehave do seu projeto dbehave e possuirá as seguintes características.

• Na primeira coluna será mostrada o texto do nome da tela que foi feita a captura ou o nome fornecido, dependendo

de qual frase foi utilizada.

• Na segunda coluna é exibido a imagem de referência capturada do navegador de referência.

• Nas p#oximas colunas serão exibidas as imagens e informações sobre a comparação com os navegadores

• Imagem Original (opção que vem selecionada) do navegador que será comparado.

• Imagem Estática que mostra a diferença entre os 2 navegadores na cor vermelha.

• Imagem Dinâmica que mostra a diferença entre os navegadores por meio de um GIF que alterna entre os 2

navegadores.

• Percentual de diferença entre os 2 navegadores.

Exemplo de Relatório de Teste de Regressão de Layout

55

ColaboraçãoEste capítulo apresenta algumas orientações aos colaboradores do projeto, como convenções e padrões de

codificação.

12.1. Templates de Codificação

Os templates de codificação ajudam a manter os padrões de escrita de código entre os colaboradores do projeto. O

padrão ajuda na leitura e entendimento das implementações, principalmente quando há comparação entre versões

de código nos pull requests.

A seguir está apresentado o template para codificação na IDE eclipse: Download. [docs/formatter-profile-demoiselle-

behave.xml]

docs/formatter-profile-demoiselle-behave.xml



56