Automação end-to-end com Docker

Requisito mínimo:

ruby 2.5.0 >~ superior

Instalar:
  gem install cucumber
  gem install rspec

Criar pasta local e criar estrutura do projeto

Acessar pasta criada e executar o seguinte comando no terminal:

  cucumber --init

Saída terminal:

╰─➤  cucumber --init
  create   features
  create   features/step_definitions
  create   features/support
  create   features/support/env.rb

step_definitions - pasta onde são executados os testes
support - pasta disponilizada para configurações
env.rb - arquivo de configurações de ambiente do projeto

Essa é a configuração padrão ao executar o comando, na seguência do passo a passo iremos incluir mais configurações para deixar o projeto completo.

Na pasta raiz criar arquivo Gemfile com as seguinte gems:

source 'http://rubygems.org'

gem 'capybara'
gem 'chromedriver-helper'
gem 'cucumber'
gem 'geckodriver-helper', '~> 0.21.0'
gem 'rspec'
gem 'selenium-webdriver'
gem 'site_prism', '2.13'

Adicionar os requires no arquivo env.rb e configurar o Capybara

require 'capybara/cucumber'
require 'selenium-webdriver'
require 'site_prism'

Capybara.configure do |config|
  config.default_driver = :selenium_chrome
  config.app_host = 'https://automacaocombatista.herokuapp.com'
  config.default_max_wait_time = 10
end

Criar duas pastas dentro de features:

specs (executar as features)
pages (page objects)

Na pasta raiz criar a pasta reports

reports - irá armazenar as evidências dos cenários executado futuramente

Criar arquivo hooks.rb dentro de support para configurar o screenshot ao final de cada cenário

After do |scenario|
  scenario_name = scenario.name.gsub(/\s+/,'_').tr('/','_')
  if scenario.failed?
    tirar_foto(scenario_name.downcase!, 'falhou')
  else
    tirar_foto(scenario_name.downcase!, 'passou')
  end
end

Criar arquivo helper.rb dentro de support

module Helper
  def tirar_foto(nome_arquivo, resultado)
    caminho_arquivo = "reports/screenshot/test_#{resultado}"
    foto = "#{caminho_arquivo}/#{nome_arquivo}.png"
    page.save_screenshot(foto)
    embed(foto, 'image/png', 'Clique Aqui!')
  end
end

No env.rb adicionar require do helper criado e inclui-lo como global

require 'capybara/cucumber'
require 'selenium-webdriver'
require 'site_prism'
require_relative 'helper.rb'

World(Helper)

Capybara.configure do |config|
  config.default_driver = :selenium_chrome
  config.app_host = 'https://automacaocombatista.herokuapp.com'
  config.default_max_wait_time = 10
end

Configurar o cucumber, criar arquivo cucumber.yml na pasta raiz

---

default: -p pretty -p homolog

pretty: --format pretty
homolog: AMBIENTE=homolog

Dentro de support criar pasta ambientes e criar arquivo homolog.yml passando a url do ambiente

url_padrao: 'https://automacaocombatista.herokuapp.com'

Configurar o ambiente dentro do arquivo env.rb para que ele possa buscar a url dentro da pasta ambientes

require 'capybara/cucumber'
require 'selenium-webdriver'
require 'site_prism'
require_relative 'helper.rb'

AMBIENTE = ENV['AMBIENTE']
CONFIG = YAML.load_file(File.dirname(__FILE__) + "/ambientes/#{AMBIENTE}.yml")

World(Helper)

Capybara.configure do |config|
  config.default_driver = :selenium_chrome
  config.app_host = 'https://automacaocombatista.herokuapp.com'
  config.default_max_wait_time = 10
end

Ainda no env.rb alterar a url padrão do capybara para chamar pela constante CONFIG criada

require 'capybara/cucumber'
require 'selenium-webdriver'
require 'site_prism'
require_relative 'helper.rb'

AMBIENTE = ENV['AMBIENTE']
CONFIG = YAML.load_file(File.dirname(__FILE__) + "/ambientes/#{AMBIENTE}.yml")

World(Helper)

Capybara.configure do |config|
  config.default_driver = :selenium_chrome
  config.app_host = CONFIG['url_padrao']
  config.default_max_wait_time = 10
end

Criar cenario criar_usuario.feature dentro de specs em seguida rodar comando cucumber no terminal

#language: pt

Funcionalidade: Criar Usuario

-Eu como Usuario
-Quero me cadastrar com sucesso

@criar_usuario
Cenario: Cadastrar com sucesso
Quando eu cadastro meu usuario
Entao verifico se o usuario foi cadastrado

Criar arquivo criar_usuario.rb em step-definitions com os steps gerados no terminal

Quando("eu cadastro meu usuario") do
  pending # Write code here that turns the phrase above into concrete actions
end

Entao("verifico se o usuario foi cadastrado") do
  pending # Write code here that turns the phrase above into concrete actions
end

Criar nosso Pageobject para mapear os elementos em pages/criar_usuario_page.rb

class User < SitePrism::Page
  set_url '/users/new'

  element :nome, '#user_name'
  element :sobrenome, '#user_lastname'
  element :email, '#user_email'
  element :endereco, '#user_address'
  element :universidade, '#user_university'
  element :profissao, '#user_profile'
  element :genero, '#user_gender'
  element :idade, '#user_age'
  element :btn_criar, 'input[value="Criar"]'
  
  def preencher_usuario
    nome.set 'Teste'
    sobrenome.set 'Testes'
    email.set 'teste@tte.com'
    endereco.set 'Rua um dois'
    universidade.set 'Unib'
    profissao.set 'Analista'
    genero.set 'Masculino'
    idade.set '30'
    btn_criar.click
  end
end

Criar um arquivo em support chamado page_helper.rb

Dir[File.join(File.dirname(__FILE__), "../pages/*_page.rb")].each { |file| require file }

module Pages
  def user
    @user ||= User.new
  end
end

Incluir o modulo Pages como global dentro de env.rb e dar um require do arquivo criado

require 'capybara/cucumber'
require 'selenium-webdriver'
require 'site_prism'
require_relative 'helper.rb'
require_relative 'page_helper.rb'

AMBIENTE = ENV['AMBIENTE']
CONFIG = YAML.load_file(File.dirname(__FILE__) + "/ambientes/#{AMBIENTE}.yml")

World(Helper)
World(Pages)

Capybara.configure do |config|
  config.default_driver = :selenium_chrome
  config.app_host = CONFIG['url_padrao']
  config.default_max_wait_time = 10
end

Acrescentar em nosso cucumber.yml relatório

---

default: -p pretty -p homolog -p html

pretty: --format pretty
homolog: AMBIENTE=homolog
html: --format html --out=reports/relatorio.html

Arquivo criar_usuario.rb preenchido com os dados do PO na pasta step-definitions

Quando("eu cadastro meu usuario") do
  user.load
  user.preencher_usuario
end

Entao("verifico se o usuario foi cadastrado") do
  texto = find('#notice')
  expect(texto.text).to eq 'Usuário Criado com sucesso'
end

Executando o cenário

Comando: bundle exec cucumber -t@criar_usuario

Saída terminal:

╰─➤  bundle exec cucumber -t@criar_usuario
Using the default, pretty, homolog and html profiles...
# language: pt
Funcionalidade: Criar Usuario
-Eu como Usuario
-Quero me cadastrar com sucesso

  @criar_usuario
  Cenario: Cadastrar com sucesso               # features/specs/criar_usuario.feature:9
    Quando eu cadastro meu usuario             # features/step_definitions/criar_usuario.rb:1
    Entao verifico se o usuario foi cadastrado # features/step_definitions/criar_usuario.rb:6

1 scenario (1 passed)
2 steps (2 passed)
0m12.122s

Rodar em modo headless do chrome

No arquivo cumcumber.yml incluir navegadores e chamar constante no default do arquivo

---

default: -p pretty -p homolog -p html -p chrome_headless

pretty: --format pretty
homolog: AMBIENTE=homolog
html: --format html --out=reports/relatorio.html
chrome: BROWSER=chrome
chrome_headless: BROWSER=chrome_headless

No arquivo env.rb alterar a chamada do config.default_driver: Dessa forma conseguiremos sobrescrever o selenium para o que desejamos chamar no momento

De:

  config.default_driver = :selenium_chrome

Para:

    config.default_driver = :selenium

Também no arquivo env.rb configurar a chamada para subir navegador e em modo headless

Primeiro criar a constante, desta forma o browser será informado no arquivo cucumber.yml

BROWSER = ENV['BROWSER']

Em seguida incluir os drivers:

Capybara.register_driver :selenium do |app|
  if BROWSER.eql?('chrome')
    Capybara::Selenium::Driver.new(app, :browser => :chrome)
  elsif BROWSER.eql?('chrome_headless')
    Capybara::Selenium::Driver.new(app, :browser => :chrome,
      desired_capabilities: Selenium::WebDriver::Remote::Capabilities.chrome(
        'chromeOptions'=> { 'args' => ['--headless', 
                                      'disable-gpu',
                                      '--disable-dev-shm-usage',
                                      '--no-sandbox'] }
      )  
    )
  end
end

disable-dev-shm-usage => Por padrão, o Docker executa um contêiner com um espaço de memória compartilhada de 64 MB. Normalmente, isso é muito pequeno para o Chrome e fará com que o Chrome trave ou não renderize páginas grandes. Para corrigir, usamos o arg --disable-dev-shm-usage
--no-sandbox => Desabilita versão de sandbox do Chrome

Ambas serão executadas em modo headless para garantir que no Docker funcione sem problemas.

Incluir as constante criada no env.rb no arquivo cucumber.yml

---

default: -p pretty -p homolog -p html -p chrome_headless

pretty: --format pretty
homolog: AMBIENTE=homolog
html: --format html --out=reports/relatorio.html
chrome: BROWSER=chrome
chrome_headless: BROWSER=chrome_headless

Caso queira mudar um para o abrindo navegador mude para:

default: -p pretty -p homolog -p html -p chrome

Executando no Docker

REQUISITO: DOCKER INSTALADO

Instalação Linux (Ubuntu/Debian)

a. sudo apt-get update

b.  sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    software-properties-common

c. curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

d.  Baseado na arquitetura 32/64, execute:

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

e. sudo apt-get update

f. sudo apt-get install docker-ce

g. Teste
docker --help

Referência: url: https://docs.docker.com/install/linux/docker-ce/ubuntu/#install-using-the-repository

Após instalado e testado:

Criar arquivo na raiz do projeto chamado Dockerfile

FROM ruby:2.5.0
RUN apt-get update && \
    apt-get install -y net-tools

# Install depends.
RUN apt-get install -y x11vnc xvfb fluxbox wget
# Install Chrome
RUN wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
    && echo "deb http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list

RUN apt-get update && apt-get -y install google-chrome-stable

ENV APP_HOME /app
ENV HOME /root
RUN mkdir $APP_HOME
WORKDIR $APP_HOME
COPY Gemfile* $APP_HOME/
RUN bundle install
  
COPY . $APP_HOME
ENV ENVIRONMENT default

CMD bundle exec cucumber features/specs

Buildar imagem criada pelo arquivo Dockerfile

╰─➤  docker build -t < nome imagem que deseja > .

Execute o test diretamente pelo Docker após buildar imagem

╰─➤  docker run --rm < nome de sua imagem > bundle exec cucumber features/specs/criar_usuario.feature

Atenção como não temos interface gráfica dentro do Docker rodar sempre em modo Headless seus testes.

Pronto! Agora você possui um teste end-to-end automatizado completo e melhor rodando no Docker.

Caso tenha ficado com alguma duvida no passo a passo, olhem o projeto que esta nesse mesmo repositório ou entrem em contato.

OBRIGADO ;)

License

MIT License

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
features		features
reports		reports
Dockerfile		Dockerfile
Gemfile		Gemfile
Gemfile.lock		Gemfile.lock
LICENSE		LICENSE
README.md		README.md
cucumber.yml		cucumber.yml

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Automação end-to-end com Docker

Rodar em modo headless do chrome

Executando no Docker

Instalação Linux (Ubuntu/Debian)

License

About

Releases

Packages

Languages

License

emersondiego/capybara-docker

Folders and files

Latest commit

History

Repository files navigation

Automação end-to-end com Docker

Rodar em modo headless do chrome

Executando no Docker

Instalação Linux (Ubuntu/Debian)

License

About

Topics

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages