Testes de escrita para código de aplicação é algo que todos os programadores devem estar familiarizados com o fazer, independentemente da linguagem ou estrutura de escolha. RSpec é um incrível conjunto de testes e DSL (Domain-Specific Language) construído em Ruby, que permite escrever testes unitários com facilidade usando um conjunto de métodos pré-definidos. A minha introdução à escrita de código em Ruby foi estreitamente ligada à experiência de correr religiosamente RSpec para testar o que eu tinha escrito; e assim, quando comecei a aprender Rails, continuei a usar RSpec feito para uma transição mais natural e sem problemas. Por padrão, Rails usa o framework de testes MiniTest. Vamos discutir como configurar um novo projeto Rails para usar o RSpec, e então explorar usando Capybara para testar nossas views.
Primeiro, vamos criar um novo projeto Rails executando rails new NAME -T -B, onde NAME é o caminho para o diretório do projeto que deve ser criado. A bandeira -T especifica que Rails não deve configurar nenhum framework de teste para nosso novo projeto, que é exatamente o que queremos. O sinalizador -B instrui o Rails a pular a execução bundle install neste ponto. Em seguida, precisamos editar nosso Gemfile para incluir o seguinte:
group :development, :test do
gem 'rspec-rails'
gem 'capybara'
end
Isso adiciona tanto RSpec quanto Capybara aos nossos ambientes de desenvolvimento e teste. Neste ponto, execute bundle para instalar gems e quaisquer dependências que o projeto necessite. Eu gosto de cair em rails console neste ponto apenas para verificar se tudo está funcionando, e se não – eu volto ao meu Gemfile e corrijo qualquer problema.
Agora que temos o esqueleto do nosso projeto no lugar, o próximo passo é rigar a nossa suíte de testes. Simplesmente execute rails generate rspec:install neste ponto para criar o diretório spec e a estrutura de arquivos necessária. O último passo é dizer aos nossos testes para usar o Capybara. Em spec/rails_helper.rb, adicione o seguinte:
require 'capybara/rspec'
É isso mesmo para a configuração! Antes de continuarmos, vamos comentar as alterações que fizemos em nosso projeto: git add . && git commit -m "initial commit". Vamos mergulhar na criação de um controlador e fazer alguns testes!
Para os nossos propósitos de testes, vamos criar um formulário simples com algumas entradas, e depois dizer à Capybara para preencher alguns dados de amostra e enviar o formulário. Não nos preocuparemos em criar quaisquer modelos complexos ou informações persistentes para uma base de dados. Vamos dizer ao Rails para criar um controlador users e configurar algum roteamento para nós:
rails generate controller Users new --no-helper --no-assets --no-view-specs
Especificando --no-helper --no-assets estamos dizendo ao Rails para não criar nenhum ativo ou um helper para nosso controlador. A opção --no-view-specs instrui o gerador a não criar nenhum teste para as views – veremos mais tarde como criar os testes que queremos. Rails criou uma rota new para nós, que podemos ver em config/routes.rb:
Rails.application.routes.draw do
get 'users/new'
end
E em app/controllers/users_controller.rb:
class UsersController < ApplicationController
def new
end
end
Finalmente, Rails criou uma view para nós em app/views/users/new.html.erb. Vamos editar esta vista para criar um formulário simples:
<h1>User Login</h1>
<%= form_tag users_path do %>
<%= label_tag :name %>
<%= text_field_tag :name %>
<%= submit_tag "submit" %>
<% end %>
Precisamos fazer um par de coisas para terminar de ligar isto. Em routes.rb adicione o seguinte:
post 'users' => 'users#welcome'
Tambem precisamos de adicionar uma acção welcome a users_controller.rb:
def welcome
@user = params
render :welcome
end
O passo final aqui é criar views/users/welcome.html.erb e incluir algum HTML e ERB para mostrar o nome do utilizador:
<h1><%= "Welcome, #{@user}!" %></h1>
Phew! Se executarmos rails server e formos para localhost:3000/users/new em nosso navegador, devemos ser saudados com um formulário pedindo que digitemos nosso nome. Quando digitarmos nosso nome e pressionarmos o botão enviar, devemos ser redirecionados para uma página que nos cumprimente com uma calorosa saudação. Tudo isto é bom e bom, mas ter de testar o nosso código desta forma para ter a certeza que funciona sempre que adicionamos um novo formulário ou implementamos uma nova funcionalidade vai tornar-se cansativo em breve. Felizmente, uma ferramenta foi criada para testar e automatizar este processo para nós!
É aqui que a Capybara entra. Capybara é um framework que nos permite testar o código em nossas views através do preenchimento de dados do formulário, inspecionando o conteúdo da página e enviando solicitações HTTP para o navegador. Vamos configurar uma especificação para testar nosso formulário recém criado:
rails generate rspec:feature form
Isso irá gerar o arquivo spec/features/form_spec.rb. Por padrão, a Capybara espera encontrar as especificações em um diretório chamado features. Vamos editar este arquivo para adicionar um novo teste, que irá preencher o campo de texto name e pressionar submit:
require 'rails_helper'RSpec.feature "Forms", type: :feature do
it 'can enter a name and receive a greeting' do
visit 'users/new'
fill_in :name, with: "Capybara"
click_on 'submit'
expect(page).to have_content "Welcome, Capybara!"
end
end
É isso! Criamos com sucesso nosso primeiro teste no Rails usando RSpec e Capybara. Se executarmos rspec --format documentation, devemos ver que o teste passa. Sinta-se livre para experimentar – quais são as maneiras de fazer o teste falhar? Existem outros testes que poderíamos criar para este exemplo? Nós apenas arranhamos a superfície aqui – esperamos que isso o faça pensar em como você pode simplificar e automatizar o processo de testar seu código usando essas ferramentas, e adquirir o hábito de testar seu código com frequência.
Visitar aqui para o código apresentado neste post.