Table of contents
- Key benefits
- Setup
- Using Capybara with Cucumber
- Using Capybara with RSpec
- Using Capybara with Test::Unit
- Using Capybara with Minitest
- Using Capybara with Minitest::Spec
- Drivers
- The DSL
- Selectors
- Matching
- Transactions and database setup
- Asynchronous JavaScript (Ajax and friends)
- Using the DSL elsewhere
- Calling remote servers
- Using sessions
- XPath, CSS and selectors
- Beware the XPath // trap
- Configuring and adding drivers
- Gotchas:
- “Threadsafe” mode
- Development
Key benefits
- No setup necessary for Rails and Rack application. Works out of the box.
- Intuitive API which mimics the language an actual user would use.
- Switch the backend your tests run against from fast headless mode to an actual browser with no changes to your tests.
- Powerful synchronization features mean you never have to manually wait for asynchronous processes to complete.
Setup
Capybara requires Ruby 3.0.0 or later. To install, add this line to your
Gemfile
and run bundle install
:
gem 'capybara'
If the application that you are testing is a Rails app, add this line to your test helper file:
require 'capybara/rails'
If the application that you are testing is a Rack app, but not Rails, set Capybara.app to your Rack app:
Capybara.app = MyRackApp
If you need to test JavaScript, or if your app interacts with (or is located at) a remote URL, you’ll need to use a different driver. If using Rails 5.0+, but not using the Rails system tests from 5.1, you’ll probably also want to swap the “server” used to launch your app to Puma in order to match Rails defaults.
Capybara.server = :puma # Until your setup is working
Capybara.server = :puma, { Silent: true } # To clean up your test output
Using Capybara with Test::Unit
If you are using
Test::Unit
, define a base class for your Capybara tests like so:require 'capybara/dsl' class CapybaraTestCase < Test::Unit::TestCase include Capybara::DSL def teardown Capybara.reset_sessions! Capybara.use_default_driver end end
Using Capybara with Minitest
If you are using Rails system tests please see their documentation for information on selecting the driver you wish to use.
If you are using Rails, but not using Rails system tests, add the following code in your
test_helper.rb
file to make Capybara available in all test cases deriving fromActionDispatch::IntegrationTest
:require 'capybara/rails' require 'capybara/minitest' class ActionDispatch::IntegrationTest # Make the Capybara DSL available in all integration tests include Capybara::DSL # Make `assert_*` methods behave like Minitest assertions include Capybara::Minitest::Assertions # Reset sessions and driver between tests teardown do Capybara.reset_sessions! Capybara.use_default_driver end end
If you are not using Rails, define a base class for your Capybara tests like so:
require 'capybara/minitest' class CapybaraTestCase < Minitest::Test include Capybara::DSL include Capybara::Minitest::Assertions def teardown Capybara.reset_sessions! Capybara.use_default_driver end end
Remember to call
super
in any subclasses that overrideteardown
.
To switch the driver, set Capybara.current_driver
. For instance,
class BlogTest < ActionDispatch::IntegrationTest
setup do
Capybara.current_driver = Capybara.javascript_driver # :selenium by default
end
test 'shows blog posts' do
# ... this test is run with Selenium ...
end
end
Using Capybara with Minitest::Spec
Follow the above instructions for Minitest and additionally require capybara/minitest/spec
page.must_have_content('Important!')
Drivers
Capybara uses the same DSL to drive a variety of browser and headless drivers.
tests here
Capybara.use_default_driver # switch back to default driver
**Note**: switching the driver creates a new session, so you may not be able to
switch in the middle of a test.
### <a name="navigating"></a>Navigating
You can use the
<tt>[visit](http://rubydoc.info/github/teamcapybara/capybara/master/Capybara/Session#visit-instance_method)</tt>
method to navigate to other pages:
```ruby
visit('/projects')
visit(post_comments_path(post))
The visit method only takes a single parameter, the request method is always GET.
You can get the current path
of the browsing session, and test it using the have_current_path
matcher:
expect(page).to have_current_path(post_comments_path(post))
Note: You can also assert the current path by testing the value of
current_path
directly. However, using the have_current_path
matcher is
safer since it uses Capybara’s waiting behaviour
to ensure that preceding actions (such as a click_link
) have completed.
Clicking links and buttons
Full reference: Capybara::Node::Actions
You can interact with the webapp by following links and buttons. Capybara automatically follows any redirects, and submits forms associated with buttons.
click_link('id-of-link')
click_link('Link Text')
click_button('Save')
click_on('Link Text') # clicks on either links or buttons
click_on('Button Value')
Interacting with forms
Full reference: Capybara::Node::Actions
There are a number of tools for interacting with form elements:
fill_in('First Name', with: 'John')
fill_in('Password', with: 'Seekrit')
fill_in('Description', with: 'Really Long Text...')
choose('A Radio Button')
check('A Checkbox')
uncheck('A Checkbox')
attach_file('Image', '/path/to/image.jpg')
select('Option', from: 'Select Box')
Querying
Full reference: Capybara::Node::Matchers
Capybara has a rich set of options for querying the page for the existence of certain elements, and working with and manipulating those elements.
page.has_selector?('table tr')
page.has_selector?(:xpath, './/table/tr')
page.has_xpath?('.//table/tr')
page.has_css?('table tr.foo')
page.has_content?('foo')
Note: The negative forms like has_no_selector?
are different from not
has_selector?
. Read the section on asynchronous JavaScript for an explanation.
You can use these with RSpec’s magic matchers:
expect(page).to have_selector('table tr')
expect(page).to have_selector(:xpath, './/table/tr')
expect(page).to have_xpath('.//table/tr')
expect(page).to have_css('table tr.foo')
expect(page).to have_content('foo')
Finding
Full reference: Capybara::Node::Finders
You can also find specific elements, in order to manipulate them:
find_field('First Name').value
find_field(id: 'my_field').value
find_link('Hello', :visible => :all).visible?
find_link(class: ['some_class', 'some_other_class'], :visible => :all).visible?
find_button('Send').click
find_button(value: '1234').click
find(:xpath, ".//table/tr").click
find("#overlay").find("h1").click
all('a').each { |a| a[:href] }
If you need to find elements by additional attributes/properties you can also pass a filter block, which will be checked inside the normal waiting behavior. If you find yourself needing to use this a lot you may be better off adding a custom selector or adding a filter to an existing selector.
find_field('First Name'){ |el| el['data-xyz'] == '123' }
find("#img_loading"){ |img| img['complete'] == true }
Note: find
will wait for an element to appear on the page, as explained in the
Ajax section. If the element does not appear it will raise an error.
These elements all have all the Capybara DSL methods available, so you can restrict them to specific parts of the page:
find('#navigation').click_link('Home')
expect(find('#navigation')).to have_button('Sign out')
Scoping
Capybara makes it possible to restrict certain actions, such as interacting with forms or clicking links and buttons, to within a specific area of the page. For this purpose you can use the generic within method. Optionally you can specify which kind of selector to use.
within("li#employee") do
fill_in 'Name', with: 'Jimmy'
end
within(:xpath, ".//li[@id='employee']") do
fill_in 'Name', with: 'Jimmy'
end
There are special methods for restricting the scope to a specific fieldset, identified by either an id or the text of the fieldset’s legend tag, and to a specific table, identified by either id or text of the table’s caption tag.
within_fieldset('Employee') do
fill_in 'Name', with: 'Jimmy'
end
within_table('Employee') do
fill_in 'Name', with: 'Jimmy'
end
Working with windows
Capybara provides some methods to ease finding and switching windows:
facebook_window = window_opened_by do
click_button 'Like'
end
within_window facebook_window do
find('#login_email').set('a@example.com')
find('#login_password').set('qwerty')
click_button 'Submit'
end
Selectors
Helpers and matchers that accept Selectors share a common method signature that includes:
- a positional Name argument
- a positional Locator argument
- keyword Filter arguments
- a predicate Filter block argument
These arguments are usually optional in one way or another.
Name
The name argument determines the Selector to use. The argument is optional when
a helper explicitly conveys the selector name (for example, find_field
uses :field
, find_link
uses :link
, etc):
page.html # => '<a href="/">Home</a>'
page.find(:link) == page.find_link
page.html # => '<input>'
page.find(:field) == page.find_field
find by the element’s [id] attribute
page.find(:id, ‘greeting’) == page.find_by_id(‘greeting’) # => true
find by the element’s [id] attribute
page.find(:field, ‘greeting’) == page.find_field(‘greeting’) # => true
find by the element’s [name] attribute
page.find(:field, ‘content’) == page.find_field(‘content’) # => true
find by the
page.find(:field, ‘Greeting’) == page.find_field(‘Greeting’) # => true
page.html # => ‘
content
page.find(:table_row, [‘1’, ‘2’]) == page.find(:css, ‘tr:last-of-type’) # => true find by page.find(:table_row, ‘A’ => ‘1’) == page.find(:table_row, ‘B’ => ‘2’) # => true
The predicate block is always optional. When there are results for a selector query, the block is called with each item in the result set. When the block evaluates to true, the item is included from the result set. Otherwise, the item is excluded:
MatchingIt is possible to customize how Capybara finds elements. At your disposal
are two options, Exactness
For example:
StrategyUsing
The default for Transactions and database setupNote: Rails 5.1+ “safely” shares the database connection between the app and test threads. Therefore, if using Rails 5.1+ you SHOULD be able to ignore this section. Some Capybara drivers need to run against an actual HTTP server. Capybara takes care of this and starts one for you in the same process as your test, but on another thread. Selenium is one of those drivers, whereas RackTest is not. If you are using a SQL database, it is common to run every test in a transaction, which is rolled back at the end of the test, rspec-rails does this by default out of the box for example. Since transactions are usually not shared across threads, this will cause data you have put into the database in your test code to be invisible to Capybara. Cucumber handles this by using truncation instead of transactions, i.e. they empty out the entire database after each test. You can get the same behaviour by using a gem such as database_cleaner. Asynchronous JavaScript (Ajax and friends)When working with asynchronous JavaScript, you might come across situations where you are attempting to interact with an element which is not yet present on the page. Capybara automatically deals with this by waiting for elements to appear on the page. When issuing instructions to the DSL such as:
If clicking on the foo link triggers an asynchronous process, such as an Ajax request, which, when complete will add the bar link to the page, clicking on the bar link would be expected to fail, since that link doesn’t exist yet. However, Capybara is smart enough to retry finding the link for a brief period of time before giving up and throwing an error. The same is true of the next line, which looks for the content baz on the page; it will retry looking for that content for a brief time. You can adjust how long this period is (the default is 2 seconds):
Be aware that because of this behaviour, the following two statements are not equivalent, and you should always use the latter!
First expression:
Second expression:
Capybara’s RSpec matchers, however, are smart enough to handle either form. The two following statements are functionally equivalent:
Capybara’s waiting behaviour is quite advanced, and can deal with situations such as the following line of code:
Even if JavaScript causes Using sessionsCapybara manages named sessions (:default if not specified) allowing multiple sessions using the same driver and test app instance to be interacted with. A new session will be created using the current driver if a session with the given name using the current driver and test app instance is not found. Named sessionsTo perform operations in a different session and then revert to the previous session
To permanently switch the current session to a different session
Using sessions manuallyFor ultimate control, you can instantiate and use a Session manually.
XPath, CSS and selectorsCapybara does not try to guess what kind of selector you are going to give it, and will always use CSS by default. If you want to use XPath, you’ll need to do:
Alternatively you can set the default selector to XPath:
Capybara provides a number of other built-in selector types. The full list, along with applicable filters, can be seen at built-in selectors Capybara also allows you to add custom selectors, which can be very useful if you find yourself using the same kinds of selectors very often. The examples below are very simple, and there are many available features not demonstrated. For more in-depth examples please see Capybaras built-in selector definitions.
The block given to xpath must always return an XPath expression as a String, or an XPath expression generated through the XPath gem. You can now use these selectors like this:
Beware the XPath // trapIn XPath the expression // means something very specific, and it might not be what you think. Contrary to common belief, // means “anywhere in the document” not “anywhere in the current context”. As an example:
You might expect this to find all script tags in the body, but actually, it finds all script tags in the entire document, not only those in the body! What you’re looking for is the .// expression which means “any descendant of the current node”:
The same thing goes for within:
Configuring and adding driversCapybara makes it convenient to switch between different drivers. It also exposes an API to tweak those drivers with whatever settings you want, or to add your own drivers. This is how to override the selenium driver configuration to use chrome:
However, it’s also possible to give this configuration a different name.
Then tests can switch between using different browsers effortlessly:
Whatever is returned from the block should conform to the API described by Capybara::Driver::Base, it does not however have to inherit from this class. Gems can use this API to add their own drivers to Capybara. The Selenium wiki has additional info about how the underlying driver can be configured. Articles
|