How we test our Rails projects (2/3)

Icône flèche bleue vers la gauche
Back to blog
How we test our Rails projects (2/3)

How we test our Rails projects (2/3)

May 8, 2016


This blog post is the second of a series of 3 articles explaining how we write automatic tests for our Rails projects.

The 3 parts discuss the following topics :

Part 2 : The structure


Since we are using RSpec, we won’t be using the test folder but the spec one.

This folder will keep all our example files (an example is any kind of automatic test in RSpec terms), but also code and assets specific to our tests. More precisely there will be 3 subfolders dedicated to store files helping our examples and as many folders storing example files.

The 3 sub folders containing helping files are :

  • factories : Where we put FactoryGirl factory definitions. Usually one file by object tree we need to build.  
  • resources : Where we put static files we need in our examples. Those can be files we need to simulate an upload, files we need to compare with the result of a file generation, picture files we need to populate avatars of our users, etc. When we need a file to be used as-is without the need of parsing it, we will put it there.  
  • support : Where we put all the supporting code for our test environment. This is the biggest one of the three and has its own sub structure.  

The other subdirectories will mostly mimic the structure of your app folder. We usually follow a structure of stereotyped folders ( the rails way ) for the common code and topic folders for specific code. Thus if we have the subfolders app/models/user.rb, app/api_clients/twilio_client.rb, and app/invoicing/invoice.rb files, we will have the spec/models/user_spec.rb, spec/api_clients/twilio_client_spec.rb and spec/invoicing/invoice_spec.rb.

I said mostly because there is one additional folder in spec which does not appear in the app folder : the features folder.


This folder is where we put our feature specs.

We have tried using special tools like Cucumber for our feature specs. It turns out for us that the cost of an additional tool and an additional language is not worth the effort. Especially since, in our usual projects, the product owner almost never read the user stories, even less writes them; the project manager is responsible for translating the needs to the developer and the developer writes and maintains the stories. Therefore we wanted a tool making the task easy for the developer and the combination of RSpec, SitePrism and Capybara is the best we have found to enable the developers to feel at home.

This folder hosts the feature specs but what does our feature specs looks like ?

Our files (code and specs) are always structured to hoist the important parts at the top of the file and the boilerplate at the bottom. For our feature specs this means that the file has a short name matching its file name allowing us to easily jump on them in our editor, then has a longer description in the form of a user story, then the code really begins.

The code starts with the inclusion of the required shared_contexts for setting up a coarse grained state of the app, then a background block calling some private methods for a more fine grained initial setup.

Then we have the scenarios. Each scenario has a short descriptive name allowing us to differentiate it from the other scenarios of the same feature (meaning a feature file with a single scenario can have a very simple name). The scenario starts by calling some private methods to put the application in the exact state required for that scenario. Then we have a succession of private method calls written to look like sentences. Active first person sentences are used to describe how the user interacts with the application. Passive sentences are used to describe assertions made in order to continue or fail the examples. Other active sentences are used to describe external actions happening.

This technique is very simple and gets almost all the benefits from tools like cucumber without the hassle of them. As developers we are not at all disturbed by the snake case transformation of the sentences and the 3 simple gramatical rules enable us to immediately know what kind of step we are in.

After the scenarios we enter the private area where we can have test values in the form of let() calls and the definition of all the private methods we have called earlier.

Here is an example illustrating all these concepts :

We imagine a story where a new client must have its ticket payment validated before downloading its concert ticket.

# /spec/features/fresh_client_want_to_download_
require 'rails_helper'

RSpec.feature 'a user who has bought ticket using bank transfer want to download its ticket', '
 As a User having bought concert tickets using bank transfer
 In order to be able to enter in the concert room
 I want to download my tickets
' do

 include_context 'users exist'
 include_context 'concert exist'
 include_context('a ticket has been bought using bank transfer') do
   let(:ticket_concert){ concert }
   let(:ticket_buyer){ client }

 background do

 scenario 'I can download my tickets after an admin validation', :js  do

   as(client) do

   as(admin) do

   as(client) do




As you can see, the scenario is quite easy to follow and when we read a sentence we can immediately know if it is a user action step ( i_go_to_my_dashboard ), an assertion step (my_ticket_is_not_available_until_my_payment_has_been_validated) or an external action step ( free_some_seats_for_the_concert ).

The question you are probably asking yourself is : “But where is the code ?”. The code appears after the private keyword. we have a list of let() statement for when a value needs to be used in multiple steps but we don’t really care about what it is ( let(:street_name){ 'Boulevard Acme' }), and a lot of very small private methods translating those steps into method calls like these :

def i_go_to_my_dashboard

def i_follow_the_email_annoucing_me_my_ticket_is_available
 last_email = mailbox_for(
 expect(last_email.subject).to eq I18n.t("ticket_mailer.available_ticket.subject")
 click_email_link_matching(%r'my/tickets', last_email)

Ok but where do those as(), navbar, client, … methods come from ? You haven’t told us everything !

Not yet, but here come the best part …


This folder contains all the supporting code for our examples, it will enable us to :

  • Setup very easily the application in a complex state thanks to shared_contexts.  
  • Extend the Rspec DSL with some useful new keywords thanks to helpers (use them with caution).  
  • Override some behaviour in order to better isolate some components when we want to test them in isolation (testing a User record should require ActiveRecord, fair enough but not the complete Rails app juste because of Devise).  
  • Share page manipulation logic between multiple scenarios thanks to SitePrism page objects.  


The first support subfolder we are going to create is /spec/support/initializers. The purpose of this folder is to mimic /config/initializers in the sense that all of its files will be loaded during the boot process of our app. Usually one puts RSpec configuration in /spec/spec_helper.rb and Rails specific RSpec configuration in /spec/rails_helper.rb. We do put RSpec configuration in /spec/spec_helper.rb but we split /spec/spec_helper.rb config in multiple files stored in /spec/support/initializers folder. This allows us to keep /spec/rails_helper.rb smaller, to have topic config files and to have other spec helper files loading only a subset of the initializers (typically we have an /spec/activerecord_spec_helper loading only what is required to test activerecord objects).

Here is what a fresh project starts with most of the time :

capybara.rb : setup capybara and its drivers. We mostly uses poltergeist and rack-test drivers. we configure autoscreenshot upon failure and check ENV variables or metadate for diver overrides.


require 'launchy'
require 'capybara'
require 'capybara/poltergeist'
require 'capybara/rails'
require 'capybara/rspec'
require 'selenium-webdriver'
require 'capybara-screenshot'
require 'capybara-screenshot/rspec'

Capybara.register_driver :poltergeist do |app|
     js_errors: true, # break on js error
     timeout: 180, # maximum time in second for the server to produce a response
     debug: false, # more verbose log
     window_size: [1280, 800], # not responsive, used to simulate scroll when needed
     inspector: false, # use debug breakpoint and chrome inspector
     phantomjs_options: ['--ignore-ssl-errors=yes'] ,
     # extensions: [Rails.root.join('spec', 'support', 'phantomjs_ext', 'geolocation.js').expand_path.to_s]

Capybara.register_driver :chrome do |app|, :browser => :chrome)

Capybara.register_driver :firefox do |app|, :browser => :firefox)

Capybara.javascript_driver = ENV.fetch('DRIVER') { 'poltergeist' }.to_sym
Capybara.asset_host = 'http://localhost:3000' # enable asset in save_and_open_page if we have a dev server running

Capybara.configure do |config|
 config.default_selector = :css
 config.default_max_wait_time= 2
 config.match = :prefer_exact
 config.ignore_hidden_elements = true

[:chrome, :firefox, :poltergeist].each do |driver|
 RSpec.configure do |config|
   config.around(:each, driver) do |example|
     current_javascript_driver = Capybara.javascript_driver
     current_default_driver = Capybara.default_driver
     Capybara.javascript_driver = driver
     Capybara.default_driver = driver
     Capybara.javascript_driver = current_javascript_driver
     Capybara.default_driver = current_default_driver

Capybara.save_and_open_page_path = Rails.root.join('tmp', 'save_and_open_page')
Capybara::Screenshot.prune_strategy = { keep: 10 }

Capybara::Screenshot.register_driver(:chrome) do |driver, path|
 driver.browser.save_screenshot path

database_cleaner.rb : We configure database cleaner in a very simple fashion in order to either use transaction strategy during activerecord and simple feature specs , or truncation during javascripted feature specs. This file is really project dependent and this example is a simple one. Usually we add here seed management: data coming from the seed are loaded once at the beginning and excluded from the cleaning process.


require 'database_cleaner'

RSpec.configure do |config|

 config.before(:suite) do
   DatabaseCleaner.strategy = :transaction
   DatabaseCleaner.clean_with :truncation

 config.before(:each, type: :feature) do

   driver_shares_db_connection_with_specs = Capybara.current_driver == :rack_test

   if driver_shares_db_connection_with_specs
     DatabaseCleaner.strategy = :transaction
     DatabaseCleaner.strategy = :truncation

 config.before(:each) do

 config.append_after(:each) do


factory_girl.rb : We add a very small patch to factory girl allowing us to use file from the spec/resources folder. We use this in combination with Carrierwave uploaders.

require 'factory_girl'

module FactoryGirl::SyntaxSugar

 def resources_path(*parts)
   Pathname(File.join(File.realpath(__FILE__), '..', '..', '..', 'resources', *parts)).expand_path

 def resources_file(*parts) resources_path(*parts)

FactoryGirl::SyntaxRunner.include FactoryGirl::SyntaxSugar

RSpec.configure do |config|
 config.include FactoryGirl::Syntax::Methods
 config.include FactoryGirl::SyntaxSugar

 config.before(:suite) do


site_prism.rb : We add a patch to site prism allowing us to locate elements based on the data attribute data-purpose. This allows our team to work effectively between front and back developers. The backend developer must not rely on anything else than this attribute to locate an element. The front developer can change anything on the page but those attributes. It also enables us very effectively to not rely on - translateable - texts on the page.

require 'site_prism'

SitePrism.configure do |config|
 config.use_implicit_waits = true

module  SitePrismExtension

 def purpose_element(purpose, options)
   element purpose, %Q'[data-purpose="#{purpose}"]', options

 def purpose_elements(purpose, elements_name=purpose.to_s.pluralize)
   elements elements_name, %Q'[data-purpose="#{purpose}"]'

 def purpose_section(purpose, section_class)
   section purpose, section_class, %Q'[data-purpose="#{purpose}"]'

 def purpose_sections(purpose, section_class, elements_name=purpose.to_s.pluralize)
   sections elements_name, section_class, %Q'[data-purpose="#{purpose}"]'

SitePrism::Page.send :extend, SitePrismExtension
SitePrism::Section.send :extend, SitePrismExtension

then we can add the following line in spec/rails_helper.rb

Dir[Rails.root.join('spec/support/initializers/*.rb')].each { |f| require f }


In an Object Oriented world, a function is something quite uncommon. Very often they are a bad idea, especially helper functions. This folder will nonetheless expose some of those functions. They won’t be real functions but mostly extensions to objects already injected in some contexts.

We usually use the following helpers :

capybara_helpers.rb : mostly acronyms because we are lazy and some method are way too long to be written when debugging. Also some component manipulation logic, in this example methods to use jquery-datetimepicker and select2 but you should change it to what you need.


require 'site_prism'
require 'capybara/rails'
require 'capybara/poltergeist'

module Capybara::AliasHelper

 def snap

 def saop

 def resources_path(*parts)
   Pathname(File.join(File.realpath(__FILE__), '..', '..', '..', 'resources', *parts)).expand_path


module  Capybara::ComplexInputsHelpers

 def pick_date(value, element)
   if Capybara.current_driver != :rack_test && element['id'].present?

 def select_from_select2(value, select_container)
   select_container.find(".select2-selection").click # display filter
   find(".select2-search__field").set(value) # type text in filter
   find("li.select2-results__option--highlighted").click # choose option

RSpec.configure { |c| c.include Capybara::AliasHelper }
RSpec.configure { |c| c.include Capybara::ComplexInputsHelpers }

SitePrism::Page.send :include, Capybara::AliasHelper
SitePrism::Page.send :include, Capybara::ComplexInputsHelpers
SitePrism::Section.send :include, Capybara::AliasHelper
SitePrism::Section.send :include, Capybara::ComplexInputsHelpers

page_objects_helper.rb: As explained in the previous article, we use SitePrism to write page objects. Those page objects are stateless and therefore a feature spec shouldn’t care about their instantiation. We use this file to expose each page object through its own private method and use memoization to be gain a small performance optimization.

We use the Memoist gem to do the job , not because we are too lazy to do the code by ourselve but because we like the idea of separated responsibility and memoization is a performance responsibility different than the business logic it applies to. So we think using the memoize macro describe better our intent than doing the memoization by hand.

module PageObjectsHelper
 extend Memoist

 def self.page_object(helper_method, page_class)
   define_method(helper_method) do
   memoize helper_method

 page_object :navbar, Spec::Pages::Navbar
 page_object :home_page, Spec::Pages::HomePage
 page_object :login_page, Spec::Pages::LoginPage
 # And so on ...

RSpec.configure { |c| c.include PageObjectsHelper, type: :feature }

usual_steps_helper.rb : the magic as() helper. The code might need change in your project but it’s almost certain that you have scenario requiring someone to be logged in - or multiple persons. The point here is to separate everyone in its own session and leveraging the login_page login to do the authentication.

If you have blank screenshots when using this snippet, ensure you use a version of capybara-screenshot including this fix :


module UsualStepsHelper

 def as(user, options={})
   experimental = options[:experimental] || false
   session_name = "capybara_session_for_#{user.to_param}"
   using_session(session_name) do
     visit new_user_session_path
     login_page.login, user.password
     force_experimental_cookie if experimental

 def as_guest
   session_name = "capybara_session_for_guest-#{rand(1_000_000)}"
   using_session(session_name) do
     visit '/'


RSpec.configure { |c| c.include UsualStepsHelper, type: :feature }


The last folder contains the most problematic kind of code, patches. When writing tests, you typically want to assert how your code is behaving. Monkey patching your code in a test environment means you are asserting a different behaviour than the normal one, thus missing the entire point of the test.


In some circumstances, testing the real behaviour is not your responsibility, and you should not do it. I’m talking about when the use of a library or framework asks you to write some code in your object making it a slave of two masters : You and the library writer.

In those cases, you might want to patch your object to drop its relation to the library in order to test only the behaviour you have designed. It’s a fragile thing since you’re not testing the real object but it might still make sense when integrating tools from which an isolation layer is really hard and/or stupid to write.

One of those cases is Devise.

When testing a User object, or an object graph containing a User instance, We very often do not want anything Devise related. Devise is meant to be integrated directly into the User class code and in Order to remove it, we use the following patch :


require 'active_record'

module DeviseInhibitor
 def devise(*whatever)
   attr_accessor :password, :password_confirmation

ActiveRecord::Base.singleton_class.prepend DeviseInhibitor

Then we require this specific file in the example file.

When using such overrides , we always require them manually so it’s very explicit that the test is against a slightly drifted variation of the code.

We already have used this technique with gems like geocoder, too which has the same integration pattern as devise.


This folder is simply where we put globally known shared contexts. When a shared context is meant to be used in any kind of feature spec (like “Users with different roles exists”, or “A concert will happen next week”) we put the file here. We use shared_contexts as a kind of very powerful data fixtures : creating data and helper methods to access those data.

Here is an example following the previous feature spec example. including this context create the expected records and allows us to use the let statement to access the data easily.

# /spec/support/shared_contexts/ticket_has_been_bought.rb

RSpec.shared_context 'a ticket has been bought using bank transfer' do

 let(:ticket_concert){ fail "please define the concert for which this ticket has been bought" }
 let(:ticket_buyer){ fail "please define the user who has bought the ticket" }

 let(:ticket_price){ 100 }
 let(:vip_kind){ } # we imagine those records are parts of the seed

 let!(:ticket_transaction) do
   # we imagine having a factory for this record
     issued_at: 3.days.ago

 let!(:ticket) do
   # we imagine having a factory for this record
     user: ticket_buyer,
     concert: ticket_concert,
     price: ticket_price,
     transaction: ticket_transaction,


/spec/spec_helper.rb, /spec/rails_helper.rb, /spec/activerecord_spec.rb

/spec/spec_helper.rb is the smallest, fastest initializer we can write for rspec. We use all the recommanded default setting, and add just 3 additional things :

  • Collection Matchers : Because we like their expressivity very much, and since all our rspec related gems are require => false in our gemfile , we require them here.  
  • Auto looading of usual rails files : Even when we do not start Rails we like being able to benefit from the autoloading of constants from files in the app directory.  
  • Defaulting the time zone : Because we have found the hard way that problems coming from machines having different default time zones are a pain to discover.  

So here is what we add to the default file :

# /spec/spec_helper.rb
require 'rspec/collection_matchers'

require 'active_support'
require 'active_support/core_ext'
require 'active_support/dependencies'

Dir[File.join(File.dirname(__FILE__), '..', 'app', 'models')].each { |f| ActiveSupport::Dependencies.autoload_paths << f }
Dir[File.join(File.dirname(__FILE__), '..', 'app', '*')].each { |f| ActiveSupport::Dependencies.autoload_paths << f }
Dir[File.join(File.dirname(__FILE__), '..', 'app', '*', 'concerns')].each { |f| ActiveSupport::Dependencies.autoload_paths << f }

Time.zone_default= Time.find_zone!('UTC')

/spec/rails_helper.rb is the heaviest, initializer we can write for rspec. It boots the entire rails application and is used for feature spec. We load some rspec extensions we only have meaning for those kind of specs (i.e. webmock), and we load all the files described above (except the overrides of course).

We also set the default rails application locale, in order to be sure that the test process and the server process have the same default. So here is our file :

# /spec/rails_helper.rb

ENV['RAILS_ENV'] ||= 'test'

require 'spec_helper'
require File.expand_path('../../config/environment', __FILE__)
require 'rspec/rails'
# Add additional requires below this line. Rails is not loaded until this point!
require 'webmock'
require 'webmock/rspec'
WebMock.disable_net_connect!(:allow_localhost => true)

# Include all our custom setup
Dir[Rails.root.join('spec/support/initializers/*.rb')].each { |f| require f }
Dir[Rails.root.join('spec/support/pages//*.rb')].each { |f| require f }
Dir[Rails.root.join('spec/support/helpers/*.rb')].each { |f| require f }
Dir[Rails.root.join('spec/support/shared_contexts/*.rb')].each { |f| require f }


RSpec.configure do |config|
 config.use_transactional_fixtures = false

I18n.locale= :fr

/spec/activerecord_spec.rb is a custom helper for testing objects in almost isolation. We use a lot of plain old ruby objects in our apps but we do not want to completely isolate activerecord form the rest of the app only because it is tightly tied to a third party library. We accept this bound and follow the active record pattern : adding behaviour to objects representing database records. But then we need to test them of course and this doesn’t mean we want to load the entire rails application with its routing, controllers, views, assets, etc.

This is why we have this third helper :

require 'spec_helper'

require 'active_record'
require 'factory_girl'
require 'yaml'

db_configurations = YAML::load("config/database.yml")).result)

ActiveRecord::Base.send(:configurations=, db_configurations)

require_relative "support/initializers/factory_girl"
require_relative "support/initializers/database_cleaner"

require_relative 'support/overrides/devise'


This one is a long post but we hope you will find it interesting not only to understand the way we organize our files but also the real code we use. Those files are the result of a long path of small improvements and are in perpetual changes. There hasn’t been any major change in the structure for a long time but every project we work on brings its new contraints and solutions.

See you soon for the next and last article, The flow, where we will explain how we go from test to code and vice versa.

Update : The next and last part is ready, you can find it here

Ready to build your software product? Contact us!