capybara 2.15.1 → 3.36.0

data/License.txt

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2009-2016 Jonas Nicklas
+Copyright (c) 2009-2018 Thomas Walpole, Jonas Nicklas
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,15 +1,23 @@
 # Capybara
 
 [![Build Status](https://secure.travis-ci.org/teamcapybara/capybara.svg)](https://travis-ci.org/teamcapybara/capybara)
-[![Dependency Status](https://gemnasium.com/teamcapybara/capybara.svg)](https://gemnasium.com/teamcapybara/capybara)
+[![Build Status](https://ci.appveyor.com/api/projects/status/github/teamcapybara/capybara?svg=true)](https://ci.appveyor.com/api/projects/github/teamcapybara/capybara)
 [![Code Climate](https://codeclimate.com/github/teamcapybara/capybara.svg)](https://codeclimate.com/github/teamcapybara/capybara)
+[![Coverage Status](https://coveralls.io/repos/github/teamcapybara/capybara/badge.svg?branch=master)](https://coveralls.io/github/teamcapybara/capybara?branch=master)
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jnicklas/capybara?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=capybara&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=capybara&package-manager=bundler&version-scheme=semver)
 
 Capybara helps you test web applications by simulating how a real user would
 interact with your app. It is agnostic about the driver running your tests and
 comes with Rack::Test and Selenium support built in. WebKit is supported
 through an external gem.
 
+## Support Capybara
+
+If you and/or your company find value in Capybara and would like to contribute financially to its ongoing maintenance and development, please visit
+<a href="https://www.patreon.com/capybara">Patreon</a>
+
+
 **Need help?** Ask on the mailing list (please do not open an issue on
 GitHub): http://groups.google.com/group/ruby-capybara
 
@@ -26,8 +34,7 @@ GitHub): http://groups.google.com/group/ruby-capybara
     - [Selecting the Driver](#selecting-the-driver)
     - [RackTest](#racktest)
     - [Selenium](#selenium)
-    - [Capybara-webkit](#capybara-webkit)
-    - [Poltergeist](#poltergeist)
+    - [Apparition](#apparition)
 - [The DSL](#the-dsl)
     - [Navigating](#navigating)
     - [Clicking links and buttons](#clicking-links-and-buttons)
@@ -47,11 +54,13 @@ GitHub): http://groups.google.com/group/ruby-capybara
 - [Using the DSL elsewhere](#using-the-dsl-elsewhere)
 - [Calling remote servers](#calling-remote-servers)
 - [Using sessions](#using-sessions)
+    - [Named sessions](#named-sessions)
+    - [Using sessions manually](#using-sessions-manually)
 - [XPath, CSS and selectors](#xpath-css-and-selectors)
 - [Beware the XPath // trap](#beware-the-xpath--trap)
 - [Configuring and adding drivers](#configuring-and-adding-drivers)
 - [Gotchas:](#gotchas)
-- ["Threadsafe" mode](#threadsafe)
+- ["Threadsafe" mode](#threadsafe-mode)
 - [Development](#development)
 
 ## <a name="key-benefits"></a>Key benefits
@@ -65,24 +74,19 @@ GitHub): http://groups.google.com/group/ruby-capybara
 
 ## <a name="setup"></a>Setup
 
-Capybara requires Ruby 1.9.3 or later. To install, add this line to your
+Capybara requires Ruby 2.6.0 or later. To install, add this line to your
 `Gemfile` and run `bundle install`:
 
 ```ruby
 gem 'capybara'
 ```
 
-**Note:** If using Ruby < 2.0 you will also need to limit the version of rack to < 2.0
-
 If the application that you are testing is a Rails app, add this line to your test helper file:
 
 ```ruby
 require 'capybara/rails'
 ```
 
-**Note:** In Rails 4.0/4.1 the default test environment (`config/environments/test.rb`) is [not threadsafe](https://github.com/rails/rails/issues/15089).
-If you experience random errors about missing constants, add `config.allow_concurrency = false` to `config/environments/test.rb`.
-
 If the application that you are testing is a Rack app, but not Rails, set Capybara.app to your Rack app:
 
 ```ruby
@@ -134,26 +138,28 @@ There are also explicit tags for each registered driver set up for you (`@seleni
 
 ## <a name="using-capybara-with-rspec"></a>Using Capybara with RSpec
 
-Load RSpec 2+ support by adding the following line (typically to your
+Load RSpec 3.5+ support by adding the following line (typically to your
 `spec_helper.rb` file):
 
 ```ruby
 require 'capybara/rspec'
 ```
 
-If you are using Rails, put your Capybara specs in `spec/features` (only works
+If you are using Rails, put your Capybara specs in `spec/features` or `spec/system` (only works
 if [you have it configured in
-RSpec](https://www.relishapp.com/rspec/rspec-rails/docs/upgrade#file-type-inference-disabled))
+RSpec](https://relishapp.com/rspec/rspec-rails/v/4-0/docs/directory-structure))
 and if you have your Capybara specs in a different directory, then tag the
-example groups with `:type => :feature`.
+example groups with `type: :feature` or `type: :system` depending on which type of test you're writing.
+
+If you are using Rails system specs please see [their documentation](https://relishapp.com/rspec/rspec-rails/docs/system-specs/system-spec#system-specs-driven-by-selenium-chrome-headless) for selecting the driver you wish to use.
 
 If you are not using Rails, tag all the example groups in which you want to use
-Capybara with `:type => :feature`.
+Capybara with `type: :feature`.
 
 You can now write your specs like so:
 
 ```ruby
-describe "the signin process", :type => :feature do
+describe "the signin process", type: :feature do
   before :each do
     User.make(email: 'user@example.com', password: 'password')
   end
@@ -177,7 +183,7 @@ to one specific driver. For example:
 ```ruby
 describe 'some stuff which requires js', js: true do
   it 'will use the default js driver'
-  it 'will switch to one specific driver', :driver => :webkit
+  it 'will switch to one specific driver', driver: :apparition
 end
 ```
 
@@ -213,11 +219,11 @@ feature "Signing in" do
 end
 ```
 
-`feature` is in fact just an alias for `describe ..., :type => :feature`,
+`feature` is in fact just an alias for `describe ..., type: :feature`,
 `background` is an alias for `before`, `scenario` for `it`, and
 `given`/`given!` aliases for `let`/`let!`, respectively.
 
-Finally, Capybara matchers are supported in view specs:
+Finally, Capybara matchers are also supported in view specs:
 
 ```ruby
 RSpec.describe "todos/show.html.erb", type: :view do
@@ -254,7 +260,9 @@ end
 
 ## <a name="using-capybara-with-minitest"></a>Using Capybara with Minitest
 
-* If you are using Rails, add the following code in your `test_helper.rb`
+* 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 from
     `ActionDispatch::IntegrationTest`:
 
@@ -269,8 +277,7 @@ end
       include Capybara::Minitest::Assertions
 
       # Reset sessions and driver between tests
-      # Use super wherever this method is redefined in your individual test classes
-      def teardown
+      teardown do
         Capybara.reset_sessions!
         Capybara.use_default_driver
       end
@@ -335,9 +342,9 @@ For example if you'd prefer to run everything in Selenium, you could do:
 Capybara.default_driver = :selenium # :selenium_chrome and :selenium_chrome_headless are also registered
 ```
 
-However, if you are using RSpec or Cucumber, you may instead want to consider
-leaving the faster `:rack_test` as the __default_driver__, and marking only those
-tests that require a JavaScript-capable driver using `js: true` or
+However, if you are using RSpec or Cucumber (and your app runs correctly without JS),
+you may instead want to consider leaving the faster `:rack_test` as the __default_driver__, and
+marking only those tests that require a JavaScript-capable driver using `js: true` or
 `@javascript`, respectively.  By default, JavaScript tests are run using the
 `:selenium` driver. You can change this by setting
 `Capybara.javascript_driver`.
@@ -346,7 +353,7 @@ You can also change the driver temporarily (typically in the Before/setup and
 After/teardown blocks):
 
 ```ruby
-Capybara.current_driver = :webkit # temporarily select different driver
+Capybara.current_driver = :apparition # temporarily select different driver
 # tests here
 Capybara.use_default_driver       # switch back to default driver
 ```
@@ -381,42 +388,35 @@ See the section on adding and configuring drivers.
 
 ### <a name="selenium"></a>Selenium
 
-At the moment, Capybara supports [Selenium 2.0+
-(Webdriver)](http://seleniumhq.org/docs/01_introducing_selenium.html#selenium-2-aka-selenium-webdriver),
-*not* Selenium RC. In order to use Selenium, you'll need to install the
-`selenium-webdriver` gem, and add it to your Gemfile if you're using bundler.
-Provided Firefox is installed, everything is set up for you, and you should be
-able to start using Selenium right away.
+Capybara supports [Selenium 3.5+
+(Webdriver)](https://www.seleniumhq.org/projects/webdriver/).
+In order to use Selenium, you'll need to install the `selenium-webdriver` gem,
+and add it to your Gemfile if you're using bundler.
 
-**Note**: drivers which run the server in a different thread may not share the
-same transaction as your tests, causing data not to be shared between your test
-and test server, see "Transactions and database setup" below.
+Capybara pre-registers a number of named drivers that use Selenium - they are:
 
-### <a name="capybara-webkit"></a>Capybara-webkit
+  * :selenium                 => Selenium driving Firefox
+  * :selenium_headless        => Selenium driving Firefox in a headless configuration
+  * :selenium_chrome          => Selenium driving Chrome
+  * :selenium_chrome_headless => Selenium driving Chrome in a headless configuration
 
-The [capybara-webkit driver](https://github.com/thoughtbot/capybara-webkit) is for true headless
-testing. It uses QtWebKit to start a rendering engine process. It can execute JavaScript as well.
-It is significantly faster than drivers like Selenium since it does not load an entire browser.
+These should work (with relevant software installation) in a local desktop configuration but you may
+need to customize them if using in a CI environment where additional options may need to be passed
+to the browsers.  See the section on adding and configuring drivers.
 
-You can install it with:
 
-```bash
-gem install capybara-webkit
-```
-
-And you can use it by:
-
-```ruby
-Capybara.javascript_driver = :webkit
-```
+**Note**: drivers which run the server in a different thread may not share the
+same transaction as your tests, causing data not to be shared between your test
+and test server, see [Transactions and database setup](#transactions-and-database-setup) below.
 
-### <a name="poltergeist"></a>Poltergeist
+### <a name="apparition"></a>Apparition
 
-[Poltergeist](https://github.com/teampoltergeist/poltergeist) is another
-headless driver which integrates Capybara with
-[PhantomJS](http://phantomjs.org/). It is truly headless, so doesn't
-require Xvfb to run on your CI server. It will also detect and report
-any Javascript errors that happen within the page.
+The [apparition driver](https://github.com/twalpole/apparition) is a new driver that allows you to run tests using Chrome in a headless
+or headed configuration. It attempts to provide backwards compatibility with the [Poltergeist driver API](https://github.com/teampoltergeist/poltergeist)
+and [capybara-webkit API](https://github.com/thoughtbot/capybara-webkit) while allowing for the use of modern JS/CSS. It
+uses CDP to communicate with Chrome, thereby obviating the need for chromedriver. This driver is being developed by the
+current developer of Capybara and will attempt to keep up to date with new Capybara releases. It will probably be moved into the
+teamcapybara repo once it reaches v1.0.
 
 ## <a name="the-dsl"></a>The DSL
 
@@ -543,7 +543,7 @@ If you find yourself needing to use this a lot you may be better off adding a [c
 ```ruby
 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.
@@ -611,13 +611,23 @@ In drivers which support it, you can easily execute JavaScript:
 page.execute_script("$('body').empty()")
 ```
 
-For simple expressions, you can return the result of the script. Note
-that this may break with more complicated expressions:
+For simple expressions, you can return the result of the script.
 
 ```ruby
 result = page.evaluate_script('4 + 4');
 ```
 
+For more complicated scripts you'll need to write them as one expression.
+
+```ruby
+result = page.evaluate_script(<<~JS, 3, element)
+  (function(n, el){
+    var val = parseInt(el.value, 10);
+    return n+val;
+  })(arguments[0], arguments[1])
+JS
+```
+
 ### <a name="modals"></a>Modals
 
 In drivers which support it, you can accept, dismiss and respond to alerts, confirms and prompts.
@@ -736,7 +746,7 @@ Capybara 1.x, set `Capybara.match` to `:prefer_exact`.
 
 ## <a name="transactions-and-database-setup"></a>Transactions and database setup
 
-**Note:**  Rails 5.1+ now "safely" shares the database connection between the app and test threads.  Therefore,
+**Note:**  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
@@ -888,7 +898,7 @@ To permanently switch the current session to a different session
 
 ```ruby
 Capybara.session_name = "some other session"
-````
+```
 
 ### <a name="using-sessions-manually"></a>Using sessions manually
 
@@ -926,12 +936,17 @@ Capybara.default_selector = :xpath
 find('.//ul/li').text
 ```
 
-Capybara allows you to add custom selectors, which can be very useful if you
-find yourself using the same kinds of selectors very often:
+Capybara provides a number of other built-in selector types. The full list, along
+with applicable filters, can be seen at [built-in selectors](https://www.rubydoc.info/github/teamcapybara/capybara/Capybara/Selector)
+
+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.
 
 ```ruby
-Capybara.add_selector(:id) do
-  xpath { |id| XPath.descendant[XPath.attr(:id) == id.to_s] }
+Capybara.add_selector(:my_attribute) do
+  xpath { |id| XPath.descendant[XPath.attr(:my_attribute) == id.to_s] }
 end
 
 Capybara.add_selector(:row) do
@@ -948,9 +963,9 @@ an XPath expression generated through the XPath gem. You can now use these
 selectors like this:
 
 ```ruby
-find(:id, 'post_123')
-find(:row, 3)
-find(:flash_type, :notice)
+find(:my_attribute, 'post_123') # find element with matching attribute
+find(:row, 3) # find 3rd row in table body
+find(:flash_type, :notice) # find element with id of 'flash' and class of 'notice'
 ```
 
 ## <a name="beware-the-xpath--trap"></a>Beware the XPath // trap
@@ -996,6 +1011,7 @@ end
 However, it's also possible to give this configuration a different name.
 
 ```ruby
+# Note: Capybara registers this by default
 Capybara.register_driver :selenium_chrome do |app|
   Capybara::Selenium::Driver.new(app, :browser => :chrome)
 end
@@ -1041,13 +1057,22 @@ additional info about how the underlying driver can be configured.
   are testing for specific server errors and using multiple sessions make sure to test for the
   errors using the initial session (usually :default)
 
-## <a name="threadsafe"></a>"Threadsafe" mode - BETA - may change
+* If WebMock is enabled, you may encounter a "Too many open files"
+  error. A simple `page.find` call may cause thousands of HTTP requests
+  until the timeout occurs. By default, WebMock will cause each of these
+  requests to spawn a new connection. To work around this problem, you
+  may need to [enable WebMock's `net_http_connect_on_start: true`
+  parameter](https://github.com/bblimke/webmock/blob/master/README.md#connecting-on-nethttpstart).
+
+## <a name="threadsafe"></a>"Threadsafe" mode
 
 In normal mode most of Capybara's configuration options are global settings which can cause issues
 if using multiple sessions and wanting to change a setting for only one of the sessions.  To provide
 support for this type of usage Capybara now provides a "threadsafe" mode which can be enabled by setting
 
-    Capybara.threadsafe = true
+```ruby
+Capybara.threadsafe = true
+```
 
 This setting can only be changed before any sessions have been created.  In "threadsafe" mode the following
 behaviors of Capybara change
@@ -1057,11 +1082,13 @@ behaviors of Capybara change
   `app`, `reuse_server`, `default_driver`, `javascript_driver`, and (obviously) `threadsafe`.  Any drivers and servers
   registered through `register_driver` and `register_server` are also global.
 
-      my_session = Capybara::Session.new(:driver, some_app) do |config|
-        config.automatic_label_click = true # only set for my_session
-      end
-      my_session.config.default_max_wait_time = 10 # only set for my_session
-      Capybara.default_max_wait_time = 2 # will not change the default_max_wait in my_session
+  ```ruby
+  my_session = Capybara::Session.new(:driver, some_app) do |config|
+    config.automatic_label_click = true # only set for my_session
+  end
+  my_session.config.default_max_wait_time = 10 # only set for my_session
+  Capybara.default_max_wait_time = 2 # will not change the default_max_wait in my_session
+  ```
 
 * `current_driver` and `session_name` are thread specific.  This means that `using_session` and
   `using_driver` also only affect the current thread.
@@ -1072,7 +1099,8 @@ To set up a development environment, simply do:
 
 ```bash
 bundle install
-bundle exec rake  # run the test suite
+bundle exec rake  # run the test suite with Firefox - requires `geckodriver` to be installed
+bundle exec rake spec_chrome # run the test suite with Chrome - require `chromedriver` to be installed
 ```
 
 See

data/lib/capybara/config.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'forwardable'
 require 'capybara/session/config'
 
@@ -6,11 +7,12 @@ module Capybara
   class Config
     extend Forwardable
 
-    OPTIONS = [:app, :reuse_server, :threadsafe, :default_wait_time, :server, :default_driver, :javascript_driver]
+    OPTIONS = %i[
+      app reuse_server threadsafe server default_driver javascript_driver use_html5_parsing allow_gumbo
+    ].freeze
 
-    attr_accessor :app
-    attr_reader :reuse_server, :threadsafe
-    attr_reader :session_options
+    attr_accessor :app, :use_html5_parsing
+    attr_reader :reuse_server, :threadsafe, :session_options # rubocop:disable Style/BisectedAttrAccessor
     attr_writer :default_driver, :javascript_driver
 
     SessionConfig::OPTIONS.each do |method|
@@ -19,15 +21,16 @@ module Capybara
 
     def initialize
       @session_options = Capybara::SessionConfig.new
+      @javascript_driver = nil
     end
 
-    def reuse_server=(bool)
-      @reuse_server = bool
-    end
+    attr_writer :reuse_server # rubocop:disable Style/BisectedAttrAccessor
 
     def threadsafe=(bool)
-      warn "Capybara.threadsafe == true is a BETA feature and may change in future minor versions" if bool
-      raise "Threadsafe setting cannot be changed once a session is created" if (bool != threadsafe) && Session.instance_created?
+      if (bool != threadsafe) && Session.instance_created?
+        raise 'Threadsafe setting cannot be changed once a session is created'
+      end
+
       @threadsafe = bool
     end
 
@@ -35,16 +38,9 @@ module Capybara
     #
     # Return the proc that Capybara will call to run the Rack application.
     # The block returned receives a rack app, port, and host/ip and should run a Rack handler
-    # By default, Capybara will try to run webrick.
+    # By default, Capybara will try to use puma.
     #
-    def server(&block)
-      if block_given?
-        warn "DEPRECATED: Passing a block to Capybara::server is deprecated, please use Capybara::register_server instead"
-        @server = block
-      else
-        @server
-      end
-    end
+    attr_reader :server
 
     ##
     #
@@ -64,12 +60,10 @@ module Capybara
       name, options = *name if name.is_a? Array
       @server = if name.respond_to? :call
         name
+      elsif options
+        proc { |app, port, host| Capybara.servers[name.to_sym].call(app, port, host, **options) }
       else
-        if options
-          Proc.new { |app, port, host| Capybara.servers[name.to_sym].call(app,port,host,options) }
-        else
-          Capybara.servers[name.to_sym]
-        end
+        Capybara.servers[name.to_sym]
       end
     end
 
@@ -89,43 +83,22 @@ module Capybara
       @javascript_driver || :selenium
     end
 
-    # @deprecated Use default_max_wait_time instead
-    def default_wait_time
-      deprecate('default_wait_time', 'default_max_wait_time', true)
-      default_max_wait_time
-    end
-
-    # @deprecated Use default_max_wait_time= instead
-    def default_wait_time=(t)
-      deprecate('default_wait_time=', 'default_max_wait_time=')
-      self.default_max_wait_time = t
-    end
-
-    def deprecate(method, alternate_method, once=false)
+    def deprecate(method, alternate_method, once: false)
       @deprecation_notified ||= {}
-      warn "DEPRECATED: ##{method} is deprecated, please use ##{alternate_method} instead" unless once and @deprecation_notified[method]
-      @deprecation_notified[method]=true
-    end
-  end
-
-  class ConfigureDeprecator
-    def initialize(config)
-      @config = config
+      unless once && @deprecation_notified[method]
+        Capybara::Helpers.warn "DEPRECATED: ##{method} is deprecated, please use ##{alternate_method} instead: #{Capybara::Helpers.filter_backtrace(caller)}"
+      end
+      @deprecation_notified[method] = true
     end
 
-    def method_missing(m, *args, &block)
-      if @config.respond_to?(m)
-        @config.public_send(m, *args, &block)
-      elsif Capybara.respond_to?(m)
-        warn "Calling #{m} from Capybara.configure is deprecated - please call it on Capybara directly ( Capybara.#{m}(...) )"
-        Capybara.public_send(m, *args, &block)
-      else
-        super
-      end
+    def allow_gumbo=(val)
+      deprecate('allow_gumbo=', 'use_html5_parsing=')
+      self.use_html5_parsing = val
     end
 
-    def respond_to_missing?(m, include_private = false)
-      @config.respond_to_missing?(m, include_private) || Capybara.respond_to_missing?(m, include_private)
+    def allow_gumbo
+      deprecate('allow_gumbo', 'use_html5_parsing')
+      use_html5_parsing
     end
   end
-end
+end

data/lib/capybara/cucumber.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'capybara/dsl'
 require 'capybara/rspec/matchers'
 require 'capybara/rspec/matcher_proxies'
@@ -21,8 +22,6 @@ end
 Before do |scenario|
   scenario.source_tag_names.each do |tag|
     driver_name = tag.sub(/^@/, '').to_sym
-    if Capybara.drivers.has_key?(driver_name)
-      Capybara.current_driver = driver_name
-    end
+    Capybara.current_driver = driver_name if Capybara.drivers[driver_name]
   end
 end