Guia do Demoiselle Behave

Guia do Demoiselle Behave

Demoiselle Behave

iii

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

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

2. Roteiro Rápido .................................................................................................................. 7

2.1. Pré Requisitos de Uso ............................................................................................... 7

2.2. Configurando o Arquétipo ........................................................................................... 7

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

2.4. Estrutura de diretórios .............................................................................................. 10

2.5. Executando Teste ................................................................................................... 11

3. Mapeamento de Classes ................................................................................................... 15

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

3.2. Classe de Mapeamento ............................................................................................ 16

3.3. Mapeamento Parametrizável ...................................................................................... 18

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

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

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

4.1. Conceito ............................................................................................................... 21

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

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

4.4. Escrevendo um cenário ............................................................................................ 23

4.5. Parametrizando os cenários ....................................................................................... 23

4.6. Reusando os cenários .............................................................................................. 23

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

4.8. Plugin do JBehave para Eclipse .................................................................................. 25

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

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

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

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

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

6. Testando aplicações Desktop ............................................................................................. 31

6.1. Iniciando um projeto utilizando o Arquétipo (Modelo de Projeto) ........................................... 31

6.2. Iniciando um projeto utilizando um projeto existente (Projeto WebDriver) ................................. 31

6.3. Configurações Desktop ............................................................................................. 31

6.4. Mapeamentos ........................................................................................................ 31

7. Configurações dos Testes ................................................................................................. 33

7.1. Configuração de Passos (Steps) ................................................................................. 33

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

8. Execução de Testes ......................................................................................................... 35

8.1. Execução Paralela ................................................................................................... 35

8.2. Modo Background ................................................................................................... 35

8.3. Integração Contínua ................................................................................................. 36

8.4. Testes Remotos ..................................................................................................... 38

8.5. Relatórios JBehave .................................................................................................. 39

9. Conjunto de Dados .......................................................................................................... 41

9.1. Conceito ............................................................................................................... 41

9.2. Criação do XML de Dados ........................................................................................ 41

9.3. Configuração do Data Provider ................................................................................... 41

9.4. Criação da História .................................................................................................. 42

10. Testes de Regressão ...................................................................................................... 43

10.1. Conceito ............................................................................................................. 43

10.2. Como Usar .......................................................................................................... 43

10.3. Relatório ............................................................................................................. 43

11. Colaboração .................................................................................................................. 45

11.1. Templates de Codificação ........................................................................................ 45

iv

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.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

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

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

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

• [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/

demoiselle/behave/issues/310]

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]

• [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/


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

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








































Capítulo 1. Release Notes

2

• [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]

• [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


























































3

• [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]

• [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://














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















































Capítulo 1. Release Notes

4

• [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/


• [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






















































5

• [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]














































6

7

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

8

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

9

Escolhendo Maven Project.

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

Escolhendo o arquétipo jbehave-selenium-archetype.


10

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

11

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 uma consulta no Google. Para executar o teste basta clicar com

o botão direito na classe AppTeste e escolher Run as>JUnit Test.


12

Classe AppTest

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

Narrativa:

Para obter a tela inicial aparece para mim

Como um visitante

Desejo acessar o Google

Cenário: Acesso ao Google

Executando Teste

13

Dado que vou para a tela "Tela de Busca"

Então será exibido "Google"

Cenário: Pesquisa Simples


Quando informo "Demoiselle Behave" no campo "Campo de Busca"

Então será exibido "https://github.com/demoiselle/behave/"

O framework associa o campo "Campo de Busca" com o elemento searchField da classe MyPage criada de forma

a mapear os objetos da tela com o Id procurado. O Elemento locatorType informa o tipo de reconhecimento de

objetos que será utilizado no framework. No exemplo, será localizado o elemento cujo Id possui o valor "gbqfq".

@ScreenMap(name = "Tela de Busca", location = "http://www.google.com.br")

public class MyPage {

@ElementMap(name = "Campo de Busca", locatorType = ElementLocatorType.Id, locator = "gbqfq")

private TextField searchField;

@ElementMap(name = "Estou com sorte", locatorType = ElementLocatorType.Id, locator = "gbqfbb")

private Button buttonLuckSearch;

}

14

15

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

16

Ferramenta XPather

Ferramenta XPather

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

17

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.


18


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)

19

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']")


20

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;

21

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>"

• [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>"

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

22

• [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"

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>"

Escrevendo um cenário

23

• [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:"



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:"

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

24

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();

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}"


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.

Plugin do JBehave para Eclipse

25

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

• 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.

26

27

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).

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.

• 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 .

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

28

• 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.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.

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 .

• 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 .

Configurações do Integration - Autenticator ALM

29

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.

• 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.3.0.jar [http://demoiselle.sourceforge.net/repository/release/br/gov/frameworkdemoiselle/component/

behave/demoiselle-behave-integration-alm/1.3.0/demoiselle-behave-integration-alm-1.3.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.3.0/demoiselle-behave-integration-alm-1.3.0.jar




30

31

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.

6.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).

6.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>

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

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

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

<scope>test</scope>

</dependency>

6.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.

6.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 6. Testando aplicaçõ...

32

@ElementIndex(index = 1)

private TextField atributo;

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

33

Configurações dos Testes

7.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);

7.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 7. Configurações dos...

34

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");

35

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.

8.1. 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.

• 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”.

8.2. 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.

Capítulo 8. Execução de Testes

36

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:

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

8.3. 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.

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



Integração Contínua

37

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:

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:


38

Console

8.4. 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:

//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

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



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



Relatórios JBehave

39

8.5. 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:

Link para detalhes da história

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


40

Detalhamento da História

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

Cenário com Erro (Desktop)

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

41

Conjunto de Dados9.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.

9.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>

9.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 9. Conjunto de Dados

42

}

9.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"

43

Testes de RegressãoNeste capítulo ....

10.1. Conceito

...

10.2. Como Usar

...

10.3. Relatório

...

44

45

ColaboraçãoEste capítulo apresenta algumas orientações aos colaboradores do projeto, como convenções e padrões de

codificação.

11.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



46

Documents

Guia do Demoiselle Behave