capybara 2.13.0 → 2.18.0

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'
 
@@ -15,6 +15,7 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
 
   def initialize(app, options={})
     raise ArgumentError, "rack-test requires a rack application, but none was given" unless app
+    @session = nil
     @app = app
     @options = DEFAULT_OPTIONS.merge(options)
   end
@@ -43,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

@@ -13,6 +13,8 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
     def original_filename; ""; end
     def content_type; "application/octet-stream"; end
     def path; @empty_file.path; end
+    def size; 0; end
+    def read; ""; end
   end
 
   def params(button)
@@ -42,9 +44,8 @@ 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)
+                mime_info = MiniMime.lookup_by_filename(value)
+                Rack::Test::UploadedFile.new(value, (mime_info && mime_info.content_type).to_s)
               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

data/lib/capybara/rspec/matcher_proxies.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Capybara
+  module RSpecMatcherProxies
+    def all(*args)
+      if defined?(::RSpec::Matchers::BuiltIn::All) && args.first.respond_to?(:matches?)
+        ::RSpec::Matchers::BuiltIn::All.new(*args)
+      else
+        find_all(*args)
+      end
+    end
+
+    def within(*args)
+      if block_given?
+        within_element(*args, &Proc.new)
+      else
+        be_within(*args)
+      end
+    end
+  end
+
+  module DSL
+    class <<self
+      remove_method :included
+
+      def included(base)
+        warn "including Capybara::DSL in the global scope is not recommended!" if base == Object
+
+        if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
+          base.send(:include, ::Capybara::RSpecMatcherProxies)
+        end
+
+        super
+      end
+    end
+  end
+end
+
+if defined?(::RSpec::Matchers)
+  module  ::RSpec::Matchers
+    def self.included(base)
+      base.send(:include, ::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
+      super
+    end
+  end
+end

data/lib/capybara/rspec/matchers.rb

@@ -2,12 +2,15 @@
 module Capybara
   module RSpecMatchers
     class Matcher
-      include ::RSpec::Matchers::Composable if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.0'))
+      if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.0'))
+        require 'capybara/rspec/compound'
+        include ::Capybara::RSpecMatchers::Compound
+      end
 
       attr_reader :failure_message, :failure_message_when_negated
 
       def wrap(actual)
-        if actual.respond_to?("has_selector?")
+        @context_el = if actual.respond_to?("has_selector?")
           actual
         else
           Capybara.string(actual.to_s)
@@ -33,10 +36,29 @@ module Capybara
         @failure_message_when_negated = e.message
         return false
       end
+
+      def session_query_args
+        if @args.last.is_a? Hash
+          @args.last[:session_options] = session_options
+        else
+          @args.push(session_options: session_options)
+        end
+        @args
+      end
+
+      def session_options
+        @context_el ||= nil
+        if @context_el.respond_to? :session_options
+          @context_el.session_options
+        elsif @context_el.respond_to? :current_scope
+          @context_el.current_scope.session_options
+        else
+          Capybara.session_options
+        end
+      end
     end
 
     class HaveSelector < Matcher
-
       def initialize(*args, &filter_block)
         @args = args
         @filter_block = filter_block
@@ -55,7 +77,45 @@ module Capybara
       end
 
       def query
-        @query ||= Capybara::Queries::SelectorQuery.new(*@args, &@filter_block)
+        @query ||= Capybara::Queries::SelectorQuery.new(*session_query_args, &@filter_block)
+      end
+    end
+
+    class HaveAllSelectors < Matcher
+      def initialize(*args, &filter_block)
+        @args = args
+        @filter_block = filter_block
+      end
+
+      def matches?(actual)
+        wrap_matches?(actual){ |el| el.assert_all_of_selectors(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(actual)
+        raise ArgumentError, "The have_all_selectors matcher does not support use with not_to/should_not"
+      end
+
+      def description
+        "have all selectors"
+      end
+    end
+
+    class HaveNoSelectors < Matcher
+      def initialize(*args, &filter_block)
+        @args = args
+        @filter_block = filter_block
+      end
+
+      def matches?(actual)
+        wrap_matches?(actual){ |el| el.assert_none_of_selectors(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(actual)
+        raise ArgumentError, "The have_none_of_selectors matcher does not support use with not_to/should_not"
+      end
+
+      def description
+        "have no selectors"
       end
     end
 
@@ -73,7 +133,7 @@ module Capybara
       end
 
       def query
-        @query ||= Capybara::Queries::MatchQuery.new(*@args)
+        @query ||= Capybara::Queries::MatchQuery.new(*session_query_args, &@filter_block)
       end
     end
 
@@ -155,11 +215,12 @@ module Capybara
 
     class BecomeClosed
       def initialize(options)
-        @wait_time = Capybara::Queries::BaseQuery.wait(options)
+        @options = options
       end
 
       def matches?(window)
         @window = window
+        @wait_time = Capybara::Queries::BaseQuery.wait(@options, window.session.config.default_max_wait_time)
         start_time = Capybara::Helpers.monotonic_time
         while window.exists?
           return false if (Capybara::Helpers.monotonic_time - start_time) > @wait_time
@@ -181,10 +242,26 @@ module Capybara
       alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
+    # RSpec matcher for whether the element(s) matching a given selector exist
+    # See {Capybara::Node::Matcher#assert_selector}
     def have_selector(*args, &optional_filter_block)
       HaveSelector.new(*args, &optional_filter_block)
     end
 
+    # RSpec matcher for whether the element(s) matching a group of selectors exist
+    # See {Capybara::Node::Matcher#assert_all_of_selectors}
+    def have_all_of_selectors(*args, &optional_filter_block)
+      HaveAllSelectors.new(*args, &optional_filter_block)
+    end
+
+    # RSpec matcher for whether no element(s) matching a group of selectors exist
+    # See {Capybara::Node::Matcher#assert_none_of_selectors}
+    def have_none_of_selectors(*args, &optional_filter_block)
+      HaveNoSelectors.new(*args, &optional_filter_block)
+    end
+
+    # RSpec matcher for whether the current element matches a given selector
+    # See {Capybara::Node::Matchers#assert_matches_selector}
     def match_selector(*args, &optional_filter_block)
       MatchSelector.new(*args, &optional_filter_block)
     end
@@ -193,22 +270,30 @@ module Capybara
     ::RSpec::Matchers.define_negated_matcher :not_match_selector, :match_selector if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.1'))
 
 
+    # RSpec matcher for whether elements(s) matching a given xpath selector exist
+    # See {Capybara::Node::Matchers#has_xpath?}
     def have_xpath(xpath, options={}, &optional_filter_block)
       HaveSelector.new(:xpath, xpath, options, &optional_filter_block)
     end
 
+    # RSpec matcher for whether the current element matches a given xpath selector
     def match_xpath(xpath, options={}, &optional_filter_block)
       MatchSelector.new(:xpath, xpath, options, &optional_filter_block)
     end
 
+    # RSpec matcher for whether elements(s) matching a given css selector exist
+    # See {Capybara::Node::Matchers#has_css?}
     def have_css(css, options={}, &optional_filter_block)
       HaveSelector.new(:css, css, options, &optional_filter_block)
     end
 
+    # RSpec matcher for whether the current element matches a given css selector
     def match_css(css, options={}, &optional_filter_block)
       MatchSelector.new(:css, css, options, &optional_filter_block)
     end
 
+    # RSpec matcher for text on the page
+    # See {Capybara::SessionMatchers#assert_text}
     def have_text(*args)
       HaveText.new(*args)
     end
@@ -218,40 +303,56 @@ module Capybara
       HaveTitle.new(title, options)
     end
 
+    # RSpec matcher for the current path
+    # See {Capybara::SessionMatchers#assert_current_path}
     def have_current_path(path, options = {})
       HaveCurrentPath.new(path, options)
     end
 
+    # RSpec matcher for links
+    # See {Capybara::Node::Matchers#has_link?}
     def have_link(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:link, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for buttons
+    # See {Capybara::Node::Matchers#has_button?}
     def have_button(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:button, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for links
+    # See {Capybara::Node::Matchers#has_field?}
     def have_field(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:field, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for checked fields
+    # See {Capybara::Node::Matchers#has_checked_field?}
     def have_checked_field(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:field, locator, options.merge(checked: true), &optional_filter_block)
     end
 
+    # RSpec matcher for unchecked fields
+    # See {Capybara::Node::Matchers#has_unchecked_field?}
     def have_unchecked_field(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:field, locator, options.merge(unchecked: true), &optional_filter_block)
     end
 
+    # RSpec matcher for select elements
+    # See {Capybara::Node::Matchers#has_select?}
     def have_select(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:select, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for table elements
+    # See {Capybara::Node::Matchers#has_table?}
     def have_table(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:table, locator, options, &optional_filter_block)
@@ -267,4 +368,4 @@ module Capybara
       BecomeClosed.new(options)
     end
   end
-end
+end

data/lib/capybara/rspec.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
-require 'capybara/dsl'
 require 'rspec/core'
+require 'capybara/dsl'
 require 'capybara/rspec/matchers'
 require 'capybara/rspec/features'
+require 'capybara/rspec/matcher_proxies'
 
 RSpec.configure do |config|
   config.include Capybara::DSL, :type => :feature
@@ -22,6 +23,7 @@ RSpec.configure do |config|
       Capybara.use_default_driver
     end
   end
+
   config.before do
     if self.class.include?(Capybara::DSL)
       example = fetch_current_example.call(self)

data/lib/capybara/selector/filter.rb

@@ -1,47 +1,19 @@
 # frozen_string_literal: true
+require 'capybara/selector/filters/node_filter'
+require 'capybara/selector/filters/expression_filter'
+
 module Capybara
   class Selector
-    class Filter
-      def initialize(name, block, options={})
-        @name = name
-        @block = block
-        @options = options
-        @options[:valid_values] = [true,false] if options[:boolean]
-      end
-
-      def default?
-        @options.has_key?(:default)
-      end
-
-      def default
-        @options[:default]
-      end
-
-      def matches?(node, value)
-        return true if skip?(value)
-
-        if !valid_value?(value)
-          msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
-          if default?
-            warn msg + "defaulting to #{default}"
-            value = default
-          else
-            warn msg + "skipping"
-            return true
-          end
-        end
-
-        @block.call(node, value)
-      end
-
-      def skip?(value)
-        @options.has_key?(:skip_if) && value == @options[:skip_if]
-      end
-
-      private
-
-      def valid_value?(value)
-        !@options.has_key?(:valid_values) || Array(@options[:valid_values]).include?(value)
+    def self.const_missing(const_name)
+      case const_name
+      when :Filter
+        warn "DEPRECATED: Capybara::Selector::Filter is deprecated, please use Capybara::Selector::Filters::NodeFilter instead"
+        Filters::NodeFilter
+      when :ExpressionFilter
+        warn "DEPRECATED: Capybara::Selector::ExpressionFilter is deprecated, please use Capybara::Selector::Filters::ExpressionFilter instead"
+        Filters::ExpressionFilter
+      else
+        super
       end
     end
   end

data/lib/capybara/selector/filter_set.rb

@@ -13,9 +13,11 @@ module Capybara
       end
 
       def filter(name, *types_and_options, &block)
-        options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
-        types_and_options.each { |k| options[k] = true}
-        filters[name] = Filter.new(name, block, options)
+        add_filter(name, Filters::NodeFilter, *types_and_options, &block)
+      end
+
+      def expression_filter(name, *types_and_options, &block)
+        add_filter(name, Filters::ExpressionFilter, *types_and_options, &block)
       end
 
       def describe(&block)
@@ -23,14 +25,30 @@ module Capybara
       end
 
       def description(options={})
-        @descriptions.map {|desc| desc.call(options).to_s }.join
+        options_with_defaults = options.dup
+        filters.each do |name, filter|
+          options_with_defaults[name] = filter.default if filter.default? && !options_with_defaults.has_key?(name)
+        end
+
+        @descriptions.map do |desc|
+          desc.call(options_with_defaults).to_s
+        end.join
       end
 
       def filters
         @filters ||= {}
       end
 
+      def node_filters
+        filters.reject { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter) }.freeze
+      end
+
+      def expression_filters
+        filters.select { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter)  }.freeze
+      end
+
       class << self
+
         def all
           @filter_sets ||= {}
         end
@@ -43,6 +61,14 @@ module Capybara
           all.delete(name.to_sym)
         end
       end
+
+      private
+
+      def add_filter(name, filter_class, *types_and_options, &block)
+        options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
+        types_and_options.each { |k| options[k] = true}
+        filters[name] = filter_class.new(name, block, options)
+      end
     end
   end
 end

data/lib/capybara/selector/filters/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Capybara
+  class Selector
+    module Filters
+      class Base
+        def initialize(name, block, options={})
+          @name = name
+          @block = block
+          @options = options
+          @options[:valid_values] = [true,false] if options[:boolean]
+        end
+
+        def default?
+          @options.has_key?(:default)
+        end
+
+        def default
+          @options[:default]
+        end
+
+        def skip?(value)
+          @options.has_key?(:skip_if) && value == @options[:skip_if]
+        end
+
+        private
+
+        def valid_value?(value)
+          !@options.has_key?(:valid_values) || Array(@options[:valid_values]).include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selector/filters/expression_filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'capybara/selector/filters/base'
+
+module Capybara
+  class Selector
+    module Filters
+      class ExpressionFilter < Base
+        def apply_filter(expr, value)
+          return expr if skip?(value)
+
+          if !valid_value?(value)
+            msg = "Invalid value #{value.inspect} passed to expression filter #{@name} - "
+            if default?
+              warn msg + "defaulting to #{default}"
+              value = default
+            else
+              warn msg + "skipping"
+              return expr
+            end
+          end
+
+          @block.call(expr, value)
+        end
+      end
+
+      class IdentityExpressionFilter < ExpressionFilter
+        def initialize
+        end
+
+        def default?
+          false
+        end
+
+        def apply_filter(expr, _value)
+          return expr
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selector/filters/node_filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'capybara/selector/filters/base'
+
+module Capybara
+  class Selector
+    module Filters
+      class NodeFilter < Base
+        def matches?(node, value)
+          return true if skip?(value)
+
+          if !valid_value?(value)
+            msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
+            if default?
+              warn msg + "defaulting to #{default}"
+              value = default
+            else
+              warn msg + "skipping"
+              return true
+            end
+          end
+
+          @block.call(node, value)
+        end
+      end
+    end
+  end
+end