capybara 2.14.4 → 2.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 987f25342ad56a2981f48c4cee5894c01601450e
-  data.tar.gz: c9c97e994be43ebde7ec94cd8cebcfcec74c2ad3
+  metadata.gz: 4e019a48b2f87598c4c62ba40e9fc12291b8f538
+  data.tar.gz: 2625bd193da4cdab59284069d1b5b2cdd8430b89
 SHA512:
-  metadata.gz: 217162eb0ad144e6617666bc998f3f2dda3ccbd93b57f787762314f58203a53dcad4e2d78f9f760807cea15b597c3b6f3aa7533da4fe841af2aab73b211e222d
-  data.tar.gz: 59aef00f83df73f98197550976838d7b9e8690d89756a070497c3429a705b78d82b5807a89a24eebae0513277cf38bf23cf155bb32e1c6e4da17fa3b58709dee
+  metadata.gz: 682fdf80248b4da8fefe635e74f1ad57ead7559198853f67500fa9a8487f3464904d3ad622a38f0d4f73dc60e40db04cab8d965c0e3bc6a8a6467f115241d418
+  data.tar.gz: 80945a70a931293fd4929c756b39b340d5e78c20a5f547eab84264505fdbe5c9fb3461c08b9e8fc3839fcfff8e741f40b9272ae285578a33fea47f28179b86a9

data/History.md

@@ -1,3 +1,20 @@
+# Version 2.15.0
+
+Release data: unreleased
+
+### Added
+
+*  `sibling` and `ancestor` finders added [Thomas Walpole]
+*  Added ability to pass options to registered servers when setting
+*  Added basic built-in driver registrations `:selenium_chrome` and `:selenium_chrome_headless` [Thomas Walpole]
+*  Add `and_then` to Capybara RSpec matchers which behaves like the previous `and` compounder. [Thomas Walpole]
+*  Compound RSpec expectations with Capybara matchers now run both matchers inside a retry loop rather
+   than waiting for one to pass/fail before checking the second.  Will make `#or` more performant and confirm
+   both conditions are true "simultaneously" for `and`.  [Thomas Walpole]
+   If you still want the
+*  Add `Session#refresh` [Thomas Walpole]
+*  Loosened restrictions on where `Session#within_window` can be called from [Thomas Walpole]
+*  Switched from `mime-types` dependency to `mini_mime` [Jason Frey]
 # Version 2.14.4
 
 Release date: 2017-06-27

data/README.md

@@ -13,22 +13,6 @@ through an external gem.
 **Need help?** Ask on the mailing list (please do not open an issue on
 GitHub): http://groups.google.com/group/ruby-capybara
 
-**Note: Firefox 48+** If you're using Firefox with selenium-webdriver and want full functionality stay on either Firefox [45.0esr](https://ftp.mozilla.org/pub/firefox/releases/45.0esr/) or [47.0.1](https://ftp.mozilla.org/pub/firefox/releases/47.0.1/).
-If using selenium-webdriver 3.0+ this will require configuring your driver with the `marionette: false` option as shown below
-
-```ruby
-Capybara.register_driver :selenium do |app|
-  Capybara::Selenium::Driver.new(
-    app,
-    browser: :firefox,
-    desired_capabilities: Selenium::WebDriver::Remote::Capabilities.firefox(marionette: false)
-  )
-end
-```
-
-Using Firefox 48+ requires geckodriver and selenium-webdriver v3, the combo of which currently has multiple issues and is feature incomplete.
-You can read more about the missing features [here](https://github.com/teamcapybara/capybara/issues/1710).
-
 ## Table of contents
 
 - [Key benefits](#key-benefits)
@@ -88,7 +72,7 @@ Capybara requires Ruby 1.9.3 or later. To install, add this line to your
 gem 'capybara'
 ```
 
-**Note:** If using Ruby < 2.0 you will also need to limit the version of mime-types to < 3.0 and the version of rack to < 2.0
+**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:
 
@@ -106,7 +90,13 @@ 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](#drivers).
+a remote URL, you'll need to [use a different driver](#drivers).  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.
+
+```ruby
+Capybara.server = :puma # Until your setup is working
+Capybara.server = :puma, { Silent: true } # To clean up your test output
+```
 
 ## <a name="using-capybara-with-cucumber"></a>Using Capybara with Cucumber
 
@@ -140,8 +130,7 @@ Scenario: do something Ajaxy
   ...
 ```
 
-There are also explicit `@selenium` and `@rack_test`
-tags set up for you.
+There are also explicit tags for each registered driver set up for you (`@selenium`, `@rack_test`, etc).
 
 ## <a name="using-capybara-with-rspec"></a>Using Capybara with RSpec
 
@@ -343,7 +332,7 @@ these limitations, you can set up a different default driver for your features.
 For example if you'd prefer to run everything in Selenium, you could do:
 
 ```ruby
-Capybara.default_driver = :selenium
+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
@@ -392,7 +381,7 @@ See the section on adding and configuring drivers.
 
 ### <a name="selenium"></a>Selenium
 
-At the moment, Capybara supports [Selenium 2.0
+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.
@@ -747,6 +736,9 @@ 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,
+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.

data/lib/capybara.rb

@@ -413,6 +413,8 @@ module Capybara
   require 'capybara/queries/title_query'
   require 'capybara/queries/current_path_query'
   require 'capybara/queries/match_query'
+  require 'capybara/queries/ancestor_query'
+  require 'capybara/queries/sibling_query'
   require 'capybara/query'
 
   require 'capybara/node/finders'
@@ -441,14 +443,14 @@ Capybara.register_server :default do |app, port, _host|
   Capybara.run_default_server(app, port)
 end
 
-Capybara.register_server :webrick do |app, port, host|
+Capybara.register_server :webrick do |app, port, host, options={}|
   require 'rack/handler/webrick'
-  Rack::Handler::WEBrick.run(app, Host: host, Port: port, AccessLog: [], Logger: WEBrick::Log::new(nil, 0))
+  Rack::Handler::WEBrick.run(app, {Host: host, Port: port, AccessLog: [], Logger: WEBrick::Log::new(nil, 0)}.merge(options))
 end
 
-Capybara.register_server :puma do |app, port, host|
+Capybara.register_server :puma do |app, port, host, options={}|
   require 'rack/handler/puma'
-  Rack::Handler::Puma.run(app, Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false)
+  Rack::Handler::Puma.run(app, {Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false}.merge(options))
 end
 
 Capybara.configure do |config|
@@ -480,3 +482,13 @@ Capybara.register_driver :selenium do |app|
   Capybara::Selenium::Driver.new(app)
 end
 
+Capybara.register_driver :selenium_chrome do |app|
+  Capybara::Selenium::Driver.new(app, :browser => :chrome)
+end
+
+Capybara.register_driver :selenium_chrome_headless do |app|
+  browser_options = ::Selenium::WebDriver::Chrome::Options.new()
+  browser_options.args << '--headless'
+  browser_options.args << '--disable-gpu'
+  Capybara::Selenium::Driver.new(app, browser: :chrome, options: browser_options)
+end

data/lib/capybara/config.rb

@@ -51,15 +51,25 @@ module Capybara
     # Set the server to use.
     #
     #     Capybara.server = :webrick
+    #     Capybara.server = :puma, { Silent: true }
     #
-    # @param [Symbol] name     Name of the server type to use
+    # @overload server=(name)
+    #   @param [Symbol] name     Name of the server type to use
+    # @overload server=([name, options])
+    #   @param [Symbol] name Name of the server type to use
+    #   @param [Hash] options Options to pass to the server block
     # @see register_server
     #
     def server=(name)
+      name, options = *name if name.is_a? Array
       @server = if name.respond_to? :call
         name
       else
-        Capybara.servers[name.to_sym]
+        if options
+          Proc.new { |app, port, host| Capybara.servers[name.to_sym].call(app,port,host,options) }
+        else
+          Capybara.servers[name.to_sym]
+        end
       end
     end
 

data/lib/capybara/driver/base.rb

@@ -10,6 +10,10 @@ class Capybara::Driver::Base
     raise NotImplementedError
   end
 
+  def refresh
+    raise NotImplementedError
+  end
+
   def find_xpath(query)
     raise NotImplementedError
   end

data/lib/capybara/node/finders.rb

@@ -34,22 +34,66 @@ module Capybara
         else
           args.push(session_options: session_options)
         end
-        query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
-        synchronize(query.wait) do
-          if (query.match == :smart or query.match == :prefer_exact)
-            result = query.resolve_for(self, true)
-            result = query.resolve_for(self, false) if result.empty? && query.supports_exact? && !query.exact?
-          else
-            result = query.resolve_for(self)
-          end
-          if query.match == :one or query.match == :smart and result.size > 1
-            raise Capybara::Ambiguous.new("Ambiguous match, found #{result.size} elements matching #{query.description}")
-          end
-          if result.empty?
-            raise Capybara::ElementNotFound.new("Unable to find #{query.description}")
-          end
-          result.first
-        end.tap(&:allow_reload!)
+        synced_resolve Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Find an {Capybara::Node::Element} based on the given arguments that is also an ancestor of the element called on. +ancestor+ will raise an error if the element
+      # is not found.
+      #
+      # +ancestor+ takes the same options as +find+.
+      #
+      #     element.ancestor('#foo').find('.bar')
+      #     element.ancestor(:xpath, './/div[contains(., "bar")]')
+      #     element.ancestor('ul', text: 'Quox').click_link('Delete')
+      #
+      # @param (see Capybara::Node::Finders#find)
+      #
+      # @!macro waiting_behavior
+      #
+      # @option options [Boolean] match        The matching strategy to use.
+      #
+      # @return [Capybara::Node::Element]      The found element
+      # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
+      #
+      def ancestor(*args, &optional_filter_block)
+        if args.last.is_a? Hash
+          args.last[:session_options] = session_options
+        else
+          args.push(session_options: session_options)
+        end
+        synced_resolve Capybara::Queries::AncestorQuery.new(*args, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Find an {Capybara::Node::Element} based on the given arguments that is also a sibling of the element called on. +sibling+ will raise an error if the element
+      # is not found.
+      #
+      #
+      # +sibling+ takes the same options as +find+.
+      #
+      #     element.sibling('#foo').find('.bar')
+      #     element.sibling(:xpath, './/div[contains(., "bar")]')
+      #     element.sibling('ul', text: 'Quox').click_link('Delete')
+      #
+      # @param (see Capybara::Node::Finders#find)
+      #
+      # @macro waiting_behavior
+      #
+      # @option options [Boolean] match        The matching strategy to use.
+      #
+      # @return [Capybara::Node::Element]      The found element
+      # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
+      #
+      def sibling(*args, &optional_filter_block)
+        if args.last.is_a? Hash
+          args.last[:session_options] = session_options
+        else
+          args.push(session_options: session_options)
+        end
+        synced_resolve Capybara::Queries::SiblingQuery.new(*args, &optional_filter_block)
       end
 
       ##
@@ -252,6 +296,25 @@ module Capybara
         nil
       end
 
+      private
+
+      def synced_resolve(query)
+        synchronize(query.wait) do
+          if (query.match == :smart or query.match == :prefer_exact)
+            result = query.resolve_for(self, true)
+            result = query.resolve_for(self, false) if result.empty? && query.supports_exact? && !query.exact?
+          else
+            result = query.resolve_for(self)
+          end
+          if query.match == :one or query.match == :smart and result.size > 1
+            raise Capybara::Ambiguous.new("Ambiguous match, found #{result.size} elements matching #{query.description}")
+          end
+          if result.empty?
+            raise Capybara::ElementNotFound.new("Unable to find #{query.description}")
+          end
+          result.first
+        end.tap(&:allow_reload!)
+      end
     end
   end
 end

data/lib/capybara/queries/ancestor_query.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Capybara
+  module Queries
+    class AncestorQuery < MatchQuery
+      # @api private
+      def resolve_for(node, exact = nil)
+        @resolved_node = node
+        node.synchronize do
+          match_results = super(node.session.current_scope, exact)
+          node.all(:xpath, XPath.ancestor) do |el|
+            match_results.include?(el)
+          end
+        end
+      end
+
+      def description
+        desc = super
+        if @resolved_node && (child_query = @resolved_node.instance_variable_get(:@query))
+          desc += " that is an ancestor of #{child_query.description}"
+        end
+        desc
+      end
+    end
+  end
+end

data/lib/capybara/queries/selector_query.rb

@@ -43,7 +43,10 @@ module Capybara
       def label; selector.label or selector.name; end
 
       def description
-        @description = String.new("#{label} #{locator.inspect}")
+        @description = String.new()
+        @description << "visible " if visible == :visible
+        @description << "non-visible " if visible == :hidden
+        @description << "#{label} #{locator.inspect}"
         @description << " with#{" exact" if exact_text == true} text #{options[:text].inspect}" if options[:text]
         @description << " with exact text #{options[:exact_text]}" if options[:exact_text].is_a?(String)
         @description << " with id #{options[:id]}" if options[:id]

data/lib/capybara/queries/sibling_query.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Capybara
+  module Queries
+    class SiblingQuery < MatchQuery
+      # @api private
+      def resolve_for(node, exact = nil)
+        @resolved_node = node
+        node.synchronize do
+          match_results = super(node.session.current_scope, exact)
+          node.all(:xpath, XPath.preceding_sibling.union(XPath.following_sibling)) do |el|
+            match_results.include?(el)
+          end
+        end
+      end
+
+      def description
+        desc = super
+        if @resolved_node && (child_query = @resolved_node.instance_variable_get(:@query))
+          desc += " that is a sibling of #{child_query.description}"
+        end
+        desc
+      end
+    end
+  end
+end

data/lib/capybara/rack_test/browser.rb

@@ -22,6 +22,11 @@ class Capybara::RackTest::Browser
     process_and_follow_redirects(:get, path, attributes)
   end
 
+  def refresh
+    reset_cache!
+    request(last_request.fullpath, last_request.env)
+  end
+
   def submit(method, path, attributes)
     path = request_path if not path or path.empty?
     process_and_follow_redirects(method, path, attributes, {'HTTP_REFERER' => current_url})

data/lib/capybara/rack_test/driver.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'rack/test'
 require 'rack/utils'
-require 'mime/types'
+require 'mini_mime'
 require 'nokogiri'
 require 'cgi'
 
@@ -44,6 +44,10 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     browser.visit(path, attributes)
   end
 
+  def refresh
+    browser.refresh
+  end
+
   def submit(method, path, attributes)
     browser.submit(method, path, attributes)
   end

data/lib/capybara/rack_test/form.rb

@@ -42,9 +42,7 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
               if (value = field['value']).to_s.empty?
                 NilUploadedFile.new
               else
-                types = MIME::Types.type_for(value)
-                content_type = types.sort_by.with_index { |type, idx| [type.obsolete? ? 1 : 0, idx] }.first.to_s
-                Rack::Test::UploadedFile.new(value, content_type)
+                Rack::Test::UploadedFile.new(value, MiniMime.lookup_by_filename(value).content_type)
               end
             merge_param!(params, field['name'].to_s, file)
           else

data/lib/capybara/rack_test/node.rb

@@ -141,7 +141,7 @@ private
 
   # a reference to the select node if this is an option node
   def select_node
-    find_xpath('./ancestor::select').first
+    find_xpath('./ancestor::select[1]').first
   end
 
   def type

data/lib/capybara/rspec/compound.rb

@@ -0,0 +1,95 @@
+module Capybara
+  module RSpecMatchers
+    module Compound
+      include ::RSpec::Matchers::Composable
+
+      def and(matcher)
+        Capybara::RSpecMatchers::Compound::And.new(self,matcher)
+      end
+
+      def and_then(matcher)
+        ::RSpec::Matchers::BuiltIn::Compound::And.new(self, matcher)
+      end
+
+      def or(matcher)
+        Capybara::RSpecMatchers::Compound::Or.new(self, matcher)
+      end
+
+
+      class CapybaraEvaluator
+        def initialize(actual, matcher_1, matcher_2)
+          @actual        = actual
+          @matcher_1     = matcher_1
+          @matcher_2     = matcher_2
+          @match_results = Hash.new { |h, matcher| h[matcher] = matcher.matches?(@actual) }
+        end
+
+        def matcher_matches?(matcher)
+          @match_results[matcher]
+        end
+
+        def reset
+          @match_results.clear
+        end
+      end
+
+      class And < ::RSpec::Matchers::BuiltIn::Compound::And
+
+      private
+
+        def match(_expected, actual)
+          @evaluator = CapybaraEvaluator.new(actual, matcher_1, matcher_2)
+          syncer = sync_element(actual)
+          begin
+            syncer.synchronize do
+              @evaluator.reset
+              raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].all?
+              true
+            end
+          rescue
+            false
+          end
+        end
+
+        def sync_element(el)
+          if el.respond_to? :synchronize
+            el
+          elsif el.respond_to? :current_scope
+            el.current_scope
+          else
+            Capybara.string(el)
+          end
+        end
+      end
+
+      class Or < ::RSpec::Matchers::BuiltIn::Compound::Or
+
+      private
+
+        def match(_expected, actual)
+          @evaluator = CapybaraEvaluator.new(actual, matcher_1, matcher_2)
+          syncer = sync_element(actual)
+          begin
+            syncer.synchronize do
+              @evaluator.reset
+              raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].any?
+              true
+            end
+          rescue
+            false
+          end
+        end
+
+        def sync_element(el)
+          if el.respond_to? :synchronize
+            el
+          elsif el.respond_to? :current_scope
+            el.current_scope
+          else
+            Capybara.string(el)
+          end
+        end
+      end
+    end
+  end
+end