capybara 3.10.1 → 3.11.0

data/lib/capybara/rspec/matchers/base.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/compound'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class Base
+        include ::Capybara::RSpecMatchers::Matchers::Compound if defined?(::Capybara::RSpecMatchers::Matchers::Compound)
+
+        attr_reader :failure_message, :failure_message_when_negated
+
+        def initialize(*args, &filter_block)
+          @args = args.dup
+          @filter_block = filter_block
+        end
+
+      private
+
+        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 WrappedElementMatcher < Base
+        def matches?(actual)
+          element_matches?(wrap(actual))
+        rescue Capybara::ExpectationNotMet => err
+          @failure_message = err.message
+          false
+        end
+
+        def does_not_match?(actual)
+          element_does_not_match?(wrap(actual))
+        rescue Capybara::ExpectationNotMet => err
+          @failure_message_when_negated = err.message
+          false
+        end
+
+      private
+
+        def wrap(actual)
+          actual = actual.to_capybara_node if actual.respond_to?(:to_capybara_node)
+          @context_el = if actual.respond_to?(:has_selector?)
+            actual
+          else
+            Capybara.string(actual.to_s)
+          end
+        end
+      end
+
+      class NegatedMatcher
+        include ::Capybara::RSpecMatchers::Matchers::Compound if defined?(::Capybara::RSpecMatchers::Matchers::Compound)
+
+        def initialize(matcher)
+          super()
+          @matcher = matcher
+        end
+
+        def matches?(actual)
+          @matcher.does_not_match?(actual)
+        end
+
+        def does_not_match?(actual)
+          @matcher.matches?(actual)
+        end
+
+        def description
+          "not #{@matcher.description}"
+        end
+
+        def failure_message
+          @matcher.failure_message_when_negated
+        end
+
+        def failure_message_when_negated
+          @matcher.failure_message
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/become_closed.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class BecomeClosed
+        def initialize(options)
+          @options = options
+        end
+
+        def matches?(window)
+          @window = window
+          @wait_time = Capybara::Queries::BaseQuery.wait(@options, window.session.config.default_max_wait_time)
+          timer = Capybara::Helpers.timer(expire_in: @wait_time)
+          while window.exists?
+            return false if timer.expired?
+
+            sleep 0.05
+          end
+          true
+        end
+
+        def failure_message
+          "expected #{@window.inspect} to become closed after #{@wait_time} seconds"
+        end
+
+        def failure_message_when_negated
+          "expected #{@window.inspect} not to become closed after #{@wait_time} seconds"
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/compound.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+if defined?(::RSpec::Expectations::Version)
+  module Capybara
+    module RSpecMatchers
+      module Matchers
+        module Compound
+          include ::RSpec::Matchers::Composable
+
+          def and(matcher)
+            And.new(self, matcher)
+          end
+
+          def and_then(matcher)
+            ::RSpec::Matchers::BuiltIn::Compound::And.new(self, matcher)
+          end
+
+          def or(matcher)
+            Or.new(self, matcher)
+          end
+
+          class CapybaraEvaluator
+            def initialize(actual)
+              @actual = actual
+              @match_results = Hash.new { |hsh, matcher| hsh[matcher] = matcher.matches?(@actual) }
+            end
+
+            def matcher_matches?(matcher)
+              @match_results[matcher]
+            end
+
+            def reset
+              @match_results.clear
+            end
+          end
+
+          # @api private
+          module Synchronizer
+            def match(_expected, actual)
+              @evaluator = CapybaraEvaluator.new(actual)
+              syncer = sync_element(actual)
+              begin
+                syncer.synchronize do
+                  @evaluator.reset
+                  raise ::Capybara::ElementNotFound unless synchronized_match?
+
+                  true
+                end
+              rescue StandardError
+                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 And < ::RSpec::Matchers::BuiltIn::Compound::And
+            include Synchronizer
+
+          private
+
+            def synchronized_match?
+              [matcher_1_matches?, matcher_2_matches?].all?
+            end
+          end
+
+          class Or < ::RSpec::Matchers::BuiltIn::Compound::Or
+            include Synchronizer
+
+          private
+
+            def synchronized_match?
+              [matcher_1_matches?, matcher_2_matches?].any?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_current_path.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveCurrentPath < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_current_path(*@args)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_no_current_path(*@args)
+        end
+
+        def description
+          "have current path #{current_path.inspect}"
+        end
+
+      private
+
+        def current_path
+          @args.first
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_selector.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveSelector < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_selector(*@args, &@filter_block)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_no_selector(*@args, &@filter_block)
+        end
+
+        def description
+          "have #{query.description}"
+        end
+
+        def query
+          @query ||= Capybara::Queries::SelectorQuery.new(*session_query_args, &@filter_block)
+        end
+      end
+
+      class HaveAllSelectors < WrappedElementMatcher
+        def element_matches?(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 < WrappedElementMatcher
+        def element_matches?(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
+
+      class HaveAnySelectors < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_any_of_selectors(*@args, &@filter_block)
+        end
+
+        def does_not_match?(_actual)
+          el.assert_none_of_selectors(*@args, &@filter_block)
+        end
+
+        def description
+          'have any selectors'
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_style.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveStyle < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_style(*@args)
+        end
+
+        def does_not_match?(_actual)
+          raise ArgumentError, 'The have_style matcher does not support use with not_to/should_not'
+        end
+
+        def description
+          'have style'
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_text.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveText < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_text(*@args)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_no_text(*@args)
+        end
+
+        def description
+          "text #{format(text)}"
+        end
+
+        def format(content)
+          content.inspect
+        end
+
+      private
+
+        def text
+          @args[0].is_a?(Symbol) ? @args[1] : @args[0]
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_title.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveTitle < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_title(*@args)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_no_title(*@args)
+        end
+
+        def description
+          "have title #{title.inspect}"
+        end
+
+      private
+
+        def title
+          @args.first
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/match_selector.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/have_selector'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class MatchSelector < HaveSelector
+        def element_matches?(el)
+          el.assert_matches_selector(*@args, &@filter_block)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_not_matches_selector(*@args, &@filter_block)
+        end
+
+        def description
+          "match #{query.description}"
+        end
+
+        def query
+          @query ||= Capybara::Queries::MatchQuery.new(*session_query_args, &@filter_block)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selector.rb

@@ -34,7 +34,8 @@ Capybara.add_selector(:css) do
 end
 
 Capybara.add_selector(:id) do
-  xpath { |id| XPath.descendant[XPath.attr(:id) == id.to_s] }
+  xpath { |id| XPath.descendant[builder.attribute_conditions(id: id)] }
+  locator_filter {  |node, id| id.is_a?(Regexp) ? node[:id] =~ id : true }
 end
 
 Capybara.add_selector(:field) do
@@ -59,7 +60,10 @@ Capybara.add_selector(:field) do
 
   node_filter(:readonly, :boolean) { |node, value| !(value ^ node.readonly?) }
   node_filter(:with) do |node, with|
-    with.is_a?(Regexp) ? node.value =~ with : node.value == with.to_s
+    val = node.value
+    (with.is_a?(Regexp) ? val =~ with : val == with.to_s).tap do |res|
+      add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
+    end
   end
 
   describe_expression_filters do |type: nil, **options|
@@ -109,16 +113,13 @@ Capybara.add_selector(:link) do
 
   node_filter(:href) do |node, href|
     # If not a Regexp it's been handled in the main XPath
-    href.is_a?(Regexp) ? node[:href].match(href) : true
+    (href.is_a?(Regexp) ? node[:href].match(href) : true).tap do |res|
+      add_error "Expected href to match #{href.inspect} but it was #{node[:href].inspect}" unless res
+    end
   end
 
   expression_filter(:download, valid_values: [true, false, String]) do |expr, download|
-    mod = case download
-    when true then XPath.attr(:download)
-    when false then !XPath.attr(:download)
-    when String then XPath.attr(:download) == download
-    end
-    expr[mod]
+    expr[builder.attribute_conditions(download: download)]
   end
 
   describe_expression_filters do |**options|
@@ -178,7 +179,9 @@ end
 Capybara.add_selector(:link_or_button) do
   label 'link or button'
   xpath do |locator, **options|
-    self.class.all.values_at(:link, :button).map { |selector| selector.call(locator, **options, selector_config: @config) }.reduce(:union)
+    self.class.all.values_at(:link, :button).map do |selector|
+      instance_exec(locator, options, &selector.xpath)
+    end.reduce(:union)
   end
 
   node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| node.tag_name == 'a' || !(value ^ node.disabled?) }
@@ -210,7 +213,10 @@ Capybara.add_selector(:fillable_field) do
   filter_set(:_field, %i[disabled multiple name placeholder])
 
   node_filter(:with) do |node, with|
-    with.is_a?(Regexp) ? node.value =~ with : node.value == with.to_s
+    val = node.value
+    (with.is_a?(Regexp) ? val =~ with : val == with.to_s).tap do |res|
+      add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
+    end
   end
 
   describe_expression_filters
@@ -231,7 +237,12 @@ Capybara.add_selector(:radio_button) do
 
   filter_set(:_field, %i[checked unchecked disabled name])
 
-  node_filter(:option) { |node, value| node.value == value.to_s }
+  node_filter(:option) do |node, value|
+    val = node.value
+    (val == value.to_s).tap do |res|
+      add_error("Expected option value to be #{value.inspect} but it was #{val.inspect}") unless res
+    end
+  end
 
   describe_expression_filters
   describe_node_filters do |option: nil, **|
@@ -249,7 +260,12 @@ Capybara.add_selector(:checkbox) do
 
   filter_set(:_field, %i[checked unchecked disabled name])
 
-  node_filter(:option) { |node, value| node.value == value.to_s }
+  node_filter(:option) do |node, value|
+    val = node.value
+    (val == value.to_s).tap do |res|
+      add_error("Expected option value to be #{value.inspect} but it was #{val.inspect}") unless res
+    end
+  end
 
   describe_expression_filters
   describe_node_filters do |option: nil, **|
@@ -273,23 +289,29 @@ Capybara.add_selector(:select) do
     else
       node.all(:xpath, './/option', visible: false, wait: false).map { |option| option.text(:all) }
     end
-    options.sort == actual.sort
+    (options.sort == actual.sort).tap do |res|
+      add_error("Expected options #{options.inspect} found #{actual.inspect}") unless res
+    end
   end
 
   expression_filter(:with_options) do |expr, options|
     options.inject(expr) do |xpath, option|
-      xpath[Capybara::Selector.all[:option].call(option)]
+      xpath[self.class.all[:option].call(option)]
     end
   end
 
   node_filter(:selected) do |node, selected|
     actual = node.all(:xpath, './/option', visible: false, wait: false).select(&:selected?).map { |option| option.text(:all) }
-    Array(selected).sort == actual.sort
+    (Array(selected).sort == actual.sort).tap do |res|
+      add_error("Expected #{selected.inspect} to be selected found #{actual.inspect}") unless res
+    end
   end
 
   node_filter(:with_selected) do |node, selected|
     actual = node.all(:xpath, './/option', visible: false, wait: false).select(&:selected?).map { |option| option.text(:all) }
-    (Array(selected) - actual).empty?
+    (Array(selected) - actual).empty?.tap do |res|
+      add_error("Expected at least #{selected.inspect} to be selected found #{actual.inspect}") unless res
+    end
   end
 
   describe_expression_filters do |with_options: nil, **opts|
@@ -320,12 +342,14 @@ Capybara.add_selector(:datalist_input) do
 
   node_filter(:options) do |node, options|
     actual = node.find("//datalist[@id=#{node[:list]}]", visible: :all).all(:datalist_option, wait: false).map(&:value)
-    options.sort == actual.sort
+    (options.sort == actual.sort).tap do |res|
+      add_error("Expected #{options.inspect} options found #{actual.inspect}") unless res
+    end
   end
 
   expression_filter(:with_options) do |expr, options|
     options.inject(expr) do |xpath, option|
-      xpath[XPath.attr(:list) == XPath.anywhere(:datalist)[Capybara::Selector.all[:datalist_option].call(option)].attr(:id)]
+      xpath[XPath.attr(:list) == XPath.anywhere(:datalist)[self.class.all[:datalist_option].call(option)].attr(:id)]
     end
   end
 
@@ -471,7 +495,11 @@ Capybara.add_selector(:element) do
   end
 
   node_filter(:attributes, matcher: /.+/) do |node, name, val|
-    val.is_a?(Regexp) ? node[name] =~ val : true
+    next true unless val.is_a?(Regexp)
+
+    (node[name] =~ val).tap do |res|
+      add_error("Expected #{name} to match #{val.inspect} but it was #{node[name]}") unless res
+    end
   end
 
   describe_expression_filters do |**options|