rubocop-capybara 2.23.0 → 3.1.0

data/lib/rubocop/cop/capybara/rspec/find_element_value_eq.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Checks for expectations on the value of an element found by Capybara.
+        #
+        # @safety
+        #   This cop's autocorrection is unsafe because `find('input').value`
+        #   checks the value of the first matched element, while `have_field`
+        #   checks that any field on the page has the expected value.
+        #
+        # @example
+        #   # bad
+        #   expect(find('input').value).to eq('foobar')
+        #   expect(find(:css, 'input').value).to eq('foobar')
+        #   expect(find_field('Email').value).to eq('user@example.com')
+        #
+        #   # good
+        #   expect(page).to have_field(with: 'foobar')
+        #   expect(page).to have_field('Email', with: 'user@example.com')
+        #
+        class FindElementValueEq < RuboCop::Cop::Base # rubocop:disable Metrics/ClassLength
+          extend AutoCorrector
+
+          MSG = 'Prefer `have_field` over checking `find(...).value`.'
+          RESTRICT_ON_SEND = %i[expect].freeze
+          FIELD_ELEMENT_SELECTORS = %w[input textarea].freeze
+
+          # @!method find_element_value_eq(node)
+          def_node_matcher :find_element_value_eq, <<~PATTERN
+            (send
+              (send nil? :expect (send $_ :value))
+              ${:to :to_not :not_to}
+              $(send nil? :eq $_)
+            )
+          PATTERN
+
+          def on_send(node)
+            find_element_value_eq(node.parent) do |finder, to_symbol,
+                                                   matcher, expected|
+              register_offense(node, finder, to_symbol, matcher, expected)
+            end
+          end
+          alias on_csend on_send
+
+          private
+
+          def register_offense(node, finder, to_symbol, matcher, expected)
+            replacement = replacement_for_finder(finder)
+            return unless replacement
+
+            expect_target, field_locator = replacement
+            matcher_replacement =
+              replacement_matcher(to_symbol, expected, field_locator)
+
+            return add_offense(node.loc.selector) unless matcher_replacement
+
+            add_offense(node.loc.selector) do |corrector|
+              autocorrect(corrector, node, matcher, expect_target,
+                          matcher_replacement)
+            end
+          end
+
+          def replacement_for_finder(node)
+            return unless node&.send_type?
+
+            case node.method_name
+            when :find
+              replacement_for_find(node)
+            when :find_field
+              replacement_for_find_field(node)
+            end
+          end
+
+          def replacement_for_find(node)
+            if (field_locator = field_selector_locator(node.arguments))
+              return [expect_target(node), field_locator]
+            end
+
+            return unless field_element_selector?(node.arguments)
+
+            [expect_target(node), nil]
+          end
+
+          def replacement_for_find_field(node)
+            return unless node.arguments.one?
+
+            [expect_target(node), node.first_argument]
+          end
+
+          def field_element_selector?(arguments)
+            return field_element_name?(arguments.first) if arguments.one?
+
+            arguments.length == 2 &&
+              arguments.first.sym_type? &&
+              arguments.first.value == :css &&
+              field_element_name?(arguments.last)
+          end
+
+          def field_selector_locator(arguments)
+            return unless arguments.length == 2
+
+            selector_type, locator = arguments
+            return unless field_selector?(selector_type)
+
+            locator
+          end
+
+          def field_selector?(node)
+            node.sym_type? && node.value == :field
+          end
+
+          def field_element_name?(node)
+            node.str_type? && FIELD_ELEMENT_SELECTORS.include?(node.value)
+          end
+
+          def expect_target(node)
+            node.receiver&.source || 'page'
+          end
+
+          def autocorrect(corrector, node, matcher, expect_target,
+                          matcher_replacement)
+            corrector.replace(node.first_argument, expect_target)
+            corrector.replace(node.parent.loc.selector, 'to')
+            corrector.replace(matcher, matcher_replacement)
+          end
+
+          def replacement_matcher(to_symbol, expected, field_locator)
+            expected_value = replacement_value(expected)
+            return unless expected_value
+
+            matcher = to_symbol == :to ? 'have_field' : 'have_no_field'
+            args = ["with: #{expected_value}"]
+            args.unshift(replacement_locator(field_locator)) if field_locator
+
+            "#{matcher}(#{args.join(', ')})"
+          end
+
+          def replacement_locator(locator)
+            return locator.source if locator.hash_type? && !locator.braces?
+
+            replacement_value(locator)
+          end
+
+          def replacement_value(expected)
+            return if unsafe_expected_value?(expected)
+
+            if expected.hash_type? && !expected.braces?
+              return "{#{expected.source}}"
+            end
+
+            if method_call_with_no_parentheses?(expected)
+              return "(#{expected.source})"
+            end
+
+            expected.source
+          end
+
+          def unsafe_expected_value?(node)
+            node.splat_type? ||
+              (node.hash_type? && node.children.any?(&:kwsplat_type?))
+          end
+
+          def method_call_with_no_parentheses?(node)
+            node.send_type? && node.arguments? && !node.parenthesized?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara/rspec/have_content.rb

@@ -19,7 +19,7 @@ module RuboCop
         #   expect(page).to have_text('capy')
         #   expect(page).to have_no_text('bara')
         #
-        class HaveContent < ::RuboCop::Cop::Base
+        class HaveContent < RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG = 'Prefer `%<good>s` over `%<bad>s`.'

data/lib/rubocop/cop/capybara/rspec/have_selector.rb

@@ -4,20 +4,24 @@ module RuboCop
   module Cop
     module Capybara
       module RSpec
-        # Use `have_css` or `have_xpath` instead of `have_selector`.
+        # Use CSS or XPath matchers instead of generic selector matchers.
         #
         # @example
         #   # bad
         #   expect(foo).to have_selector(:css, 'bar')
+        #   expect(foo).to have_no_selector(:css, 'bar')
         #
         #   # good
         #   expect(foo).to have_css('bar')
+        #   expect(foo).to have_no_css('bar')
         #
         #   # bad
         #   expect(foo).to have_selector(:xpath, 'bar')
+        #   expect(foo).to have_no_selector(:xpath, 'bar')
         #
         #   # good
         #   expect(foo).to have_xpath('bar')
+        #   expect(foo).to have_no_xpath('bar')
         #
         # @example DefaultSelector: css (default)
         #   # bad
@@ -33,12 +37,12 @@ module RuboCop
         #   # good
         #   expect(foo).to have_xpath('bar')
         #
-        class HaveSelector < ::RuboCop::Cop::Base
+        class HaveSelector < RuboCop::Cop::Base
           extend AutoCorrector
           include RangeHelp
 
-          MSG = 'Use `%<good>s` instead of `have_selector`.'
-          RESTRICT_ON_SEND = %i[have_selector].freeze
+          MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+          RESTRICT_ON_SEND = %i[have_selector have_no_selector].freeze
           SELECTORS = %i[css xpath].freeze
 
           def on_send(node)
@@ -54,33 +58,40 @@ module RuboCop
             return unless SELECTORS.include?(type.value)
             return unless (locator = node.arguments[1])
 
-            add_offense(node, message: message_typed(type)) do |corrector|
+            replacement = replacement(node, type.value)
+            add_offense(node,
+                        message: message(node, replacement)) do |corrector|
               corrector.remove(deletion_range(type, locator))
-              corrector.replace(node.loc.selector, "have_#{type.value}")
+              corrector.replace(node.loc.selector, replacement)
             end
           end
 
-          def message_typed(type)
-            format(MSG, good: "have_#{type.value}")
-          end
-
           def deletion_range(first_argument, second_argument)
             range_between(first_argument.source_range.begin_pos,
                           second_argument.source_range.begin_pos)
           end
 
           def on_select_without_type(node)
-            add_offense(node, message: message_untyped) do |corrector|
-              corrector.replace(node.loc.selector, "have_#{default_selector}")
+            return unless (selector = default_selector)
+
+            replacement = replacement(node, selector)
+            add_offense(node,
+                        message: message(node, replacement)) do |corrector|
+              corrector.replace(node.loc.selector, replacement)
             end
           end
 
-          def message_untyped
-            format(MSG, good: "have_#{default_selector}")
+          def replacement(node, selector)
+            node.method_name.to_s.sub('selector', selector.to_s)
+          end
+
+          def message(node, replacement)
+            format(MSG, good: replacement, bad: node.method_name)
           end
 
           def default_selector
-            cop_config.fetch('DefaultSelector', 'css')
+            selector = cop_config['DefaultSelector'].to_s.to_sym
+            selector if SELECTORS.include?(selector)
           end
         end
       end

data/lib/rubocop/cop/capybara/rspec/match_style.rb

@@ -22,7 +22,7 @@ module RuboCop
         #   # good
         #   expect(page).to match_style(display: 'block')
         #
-        class MatchStyle < ::RuboCop::Cop::Base
+        class MatchStyle < RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG = 'Use `%<good>s` instead of `%<bad>s`.'

data/lib/rubocop/cop/capybara/rspec/negation_matcher.rb

@@ -24,7 +24,7 @@ module RuboCop
         #   expect(page).not_to have_selector 'a'
         #   expect(page).not_to have_css('a')
         #
-        class NegationMatcher < ::RuboCop::Cop::Base
+        class NegationMatcher < RuboCop::Cop::Base
           extend AutoCorrector
           include ConfigurableEnforcedStyle
           include CapybaraHelp

data/lib/rubocop/cop/capybara/rspec/negation_matcher_after_visit.rb

@@ -27,7 +27,7 @@ module RuboCop
         #   expect(page).to have_css('a')
         #   expect(page).not_to have_link('bar')
         #
-        class NegationMatcherAfterVisit < ::RuboCop::Cop::Base
+        class NegationMatcherAfterVisit < RuboCop::Cop::Base
           include CapybaraHelp
 
           MSG = 'Do not use negation matcher immediately after visit.'
@@ -37,7 +37,7 @@ module RuboCop
           def_node_matcher :negation_matcher?, <<~PATTERN
             {
               (send (send nil? :expect _) :to (send nil? %NEGATIVE_MATCHERS ...))
-              (send (send nil? :expect _) :not_to (send nil? %POSITIVE_MATCHERS ...))
+              (send (send nil? :expect _) {:not_to :to_not} (send nil? %POSITIVE_MATCHERS ...))
             }
           PATTERN
 

data/lib/rubocop/cop/capybara/rspec/predicate_matcher.rb

@@ -9,7 +9,7 @@ module RuboCop
           extend NodePattern::Macros
 
           EXPLICIT_MATCHER = %w[css selector style xpath].map do |suffix|
-            "matches_#{suffix}?".to_sym
+            :"matches_#{suffix}?"
           end.freeze
           MSG_INFLECTED = 'Prefer using `%<matcher_name>s` matcher over ' \
                           '`%<predicate_name>s`.'
@@ -19,6 +19,8 @@ module RuboCop
           def check_inflected(node)
             predicate_in_actual?(node) do |predicate, to, matcher|
               msg = message_inflected(predicate)
+              next add_offense(node, message: msg) if predicate.block_node
+
               add_offense(node, message: msg) do |corrector|
                 remove_predicate(corrector, predicate)
                 corrector.replace(node.loc.selector,
@@ -93,7 +95,7 @@ module RuboCop
 
           def true?(to_symbol, matcher)
             result = case matcher.method_name
-                     when :be, :eq
+                     when :be, :eq, :eql, :equal
                        matcher.first_argument.true_type?
                      when :be_truthy, :a_truthy_value
                        true
@@ -118,6 +120,12 @@ module RuboCop
           INFLECTED_MATCHER = %w[css selector style xpath].each.map do |suffix|
             "match_#{suffix}"
           end.freeze
+          SAFE_RECEIVER_TYPES = Set.new(
+            %i[
+              array complex const cvar dstr false float gvar hash int ivar
+              lvar nil rational regexp self str sym true xstr
+            ]
+          ).freeze
 
           private
 
@@ -127,8 +135,10 @@ module RuboCop
 
           def check_explicit(node) # rubocop:disable Metrics/MethodLength
             predicate_matcher?(node) do |actual, matcher|
-              add_offense(node,
-                          message: message_explicit(matcher)) do |corrector|
+              msg = message_explicit(matcher)
+              next add_offense(node, message: msg) if matcher.block_node
+
+              add_offense(node, message: msg) do |corrector|
                 corrector_explicit(corrector, node, actual, matcher)
               end
             end
@@ -169,14 +179,40 @@ module RuboCop
           def move_predicate(corrector, actual, matcher)
             predicate = to_predicate_method(matcher.method_name)
             args = args_loc(matcher).source
-            corrector.insert_after(actual,
-                                   ".#{predicate}" + args)
+            replacement = ".#{predicate}#{args}"
+
+            if actual_requires_parentheses?(actual)
+              corrector.replace(actual, "(#{actual.source})#{replacement}")
+            else
+              corrector.insert_after(actual, replacement)
+            end
           end
 
           def to_predicate_method(matcher)
             "#{matcher.to_s.sub('match_', 'matches_')}?"
           end
 
+          def actual_requires_parentheses?(actual)
+            return false if actual.begin_type?
+
+            if actual.call_type?
+              return actual_send_requires_parentheses?(actual)
+            end
+
+            !safe_receiver?(actual)
+          end
+
+          def actual_send_requires_parentheses?(actual)
+            return false if actual.method?(:[])
+
+            actual.operator_method? ||
+              (actual.arguments? && !actual.parenthesized?)
+          end
+
+          def safe_receiver?(actual)
+            SAFE_RECEIVER_TYPES.include?(actual.type)
+          end
+
           # rubocop:disable Metrics/MethodLength
           def replacement_matcher(node)
             case [cop_config['Strict'], node.method?(:to)]
@@ -241,7 +277,7 @@ module RuboCop
         #   # good - the above code is rewritten to it by this cop
         #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
         #
-        class PredicateMatcher < ::RuboCop::Cop::Base
+        class PredicateMatcher < RuboCop::Cop::Base
           extend AutoCorrector
           include ConfigurableEnforcedStyle
           include InflectedHelper

data/lib/rubocop/cop/capybara/rspec/specific_matcher.rb

@@ -26,7 +26,7 @@ module RuboCop
         #   expect(page).to have_select
         #   expect(page).to have_field(with: 'foo')
         #
-        class SpecificMatcher < ::RuboCop::Cop::Base
+        class SpecificMatcher < RuboCop::Cop::Base
           MSG = 'Prefer `%<good_matcher>s` over `%<bad_matcher>s`.'
           RESTRICT_ON_SEND = %i[have_selector have_no_selector have_css
                                 have_no_css].freeze
@@ -37,6 +37,7 @@ module RuboCop
             'select' => 'select',
             'input' => 'field'
           }.freeze
+          EXCLUDED_FIELD_TYPES = %w[hidden image submit].freeze
 
           # @!method first_argument(node)
           def_node_matcher :first_argument, <<~PATTERN
@@ -61,11 +62,16 @@ module RuboCop
           private
 
           def specific_matcher(arg)
-            splitted_arg = arg[/^\w+/, 0]
+            splitted_arg = arg[/^[\w-]+/, 0]
             SPECIFIC_MATCHER[splitted_arg]
           end
 
           def replaceable?(node, arg, matcher)
+            if matcher == 'field'
+              type = CssSelector.attributes(arg)['type'].to_s.downcase
+              return false if EXCLUDED_FIELD_TYPES.include?(type)
+            end
+
             replaceable_attributes?(arg) &&
               !text_with_regexp?(node) &&
               CapybaraHelp.replaceable_option?(node, arg, matcher) &&

data/lib/rubocop/cop/capybara/rspec/visibility_matcher.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Capybara
       module RSpec
-        # Checks for boolean visibility in Capybara finders.
+        # Checks for boolean visibility in Capybara RSpec matchers.
         #
         # Capybara lets you find elements that match a certain visibility using
         # the `:visible` option. `:visible` accepts both boolean and symbols as
@@ -12,12 +12,19 @@ module RuboCop
         # false` does not find just invisible elements, but both visible and
         # invisible elements. For expressiveness and clarity, use one of the
         # symbol values, `:all`, `:hidden` or `:visible`.
+        # Only `true` is autocorrected, to `:visible`.
+        # Set `DefaultSelector` to match `Capybara.default_selector`, or to
+        # `null` if it varies at runtime.
         # Read more at: https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all
         #
+        # @safety
+        #   This cop's autocorrection is unsafe because custom filters on
+        #   built-in selectors may treat `true` and `:visible` differently.
+        #
         # @example
         #   # bad
-        #   expect(page).to have_selector('.foo', visible: false)
-        #   expect(page).to have_css('.foo', visible: true)
+        #   expect(page).to have_selector('.foo', visible: true)
+        #   expect(page).to have_css('.foo', visible: false)
         #   expect(page).to have_link('my link', visible: false)
         #
         #   # good
@@ -25,25 +32,11 @@ module RuboCop
         #   expect(page).to have_css('.foo', visible: :all)
         #   expect(page).to have_link('my link', visible: :hidden)
         #
-        class VisibilityMatcher < ::RuboCop::Cop::Base
-          MSG_FALSE = 'Use `:all` or `:hidden` instead of `false`.'
-          MSG_TRUE = 'Use `:visible` instead of `true`.'
-          CAPYBARA_MATCHER_METHODS = %w[
-            button
-            checked_field
-            css
-            field
-            link
-            select
-            selector
-            table
-            unchecked_field
-            xpath
-          ].flat_map do |element|
-            ["have_#{element}".to_sym, "have_no_#{element}".to_sym]
-          end
+        class VisibilityMatcher < RuboCop::Cop::Base
+          extend AutoCorrector
+          include Visibility
 
-          RESTRICT_ON_SEND = CAPYBARA_MATCHER_METHODS
+          RESTRICT_ON_SEND = CapybaraHelp::VISIBILITY_MATCHER_METHODS
 
           # @!method visible_true?(node)
           def_node_matcher :visible_true?, <<~PATTERN
@@ -56,14 +49,26 @@ module RuboCop
           PATTERN
 
           def on_send(node)
-            visible_false?(node) { |arg| add_offense(arg, message: MSG_FALSE) }
-            visible_true?(node) { |arg| add_offense(arg, message: MSG_TRUE) }
+            visible_false?(node) { |arg| check_visibility(arg) }
+            visible_true?(node) do |arg|
+              check_visibility(arg) { autocorrectable?(node, arg) }
+            end
           end
 
           private
 
           def capybara_matcher?(method_name)
-            CAPYBARA_MATCHER_METHODS.include? method_name
+            RESTRICT_ON_SEND.include? method_name
+          end
+
+          def autocorrectable?(node, pair)
+            if QueryMethods.selector(node.method_name) == :selector
+              selector = node.first_argument
+              # An unknown argument may be a custom selector name.
+              return false unless selector.type?(:hash, :sym, :str, :dstr)
+            end
+
+            supported_visibility_query?(node, pair.parent)
           end
         end
       end

data/lib/rubocop/cop/capybara/rspec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Cops for the `Capybara/RSpec` department. The department's cops are
+      # registered for lazy loading and their files are loaded on demand.
+      module RSpec
+        extend LazyLoader
+
+        register_cop :CurrentPathExpectation, "#{__dir__}/rspec/current_path_expectation"
+        register_cop :CurrentUrlExpectation, "#{__dir__}/rspec/current_url_expectation"
+        register_cop :FindElementValueEq, "#{__dir__}/rspec/find_element_value_eq"
+        register_cop :HaveContent, "#{__dir__}/rspec/have_content"
+        register_cop :HaveSelector, "#{__dir__}/rspec/have_selector"
+        register_cop :MatchStyle, "#{__dir__}/rspec/match_style"
+        register_cop :NegationMatcher, "#{__dir__}/rspec/negation_matcher"
+        register_cop :NegationMatcherAfterVisit, "#{__dir__}/rspec/negation_matcher_after_visit"
+        register_cop :PredicateMatcher, "#{__dir__}/rspec/predicate_matcher"
+        register_cop :SpecificMatcher, "#{__dir__}/rspec/specific_matcher"
+        register_cop :VisibilityMatcher, "#{__dir__}/rspec/visibility_matcher"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara/specific_actions.rb

@@ -8,18 +8,18 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   find('a').click
+      #   find('a[href="/home"]').click
       #   find('button.cls').click
-      #   find('a', exact_text: 'foo').click
+      #   find('a[href="/home"]', exact_text: 'foo').click
       #   find('div button').click
       #
       #   # good
-      #   click_link
+      #   click_link(href: '/home')
       #   click_button(class: 'cls')
-      #   click_link(exact_text: 'foo')
+      #   click_link(href: '/home', exact_text: 'foo')
       #   find('div').click_button
       #
-      class SpecificActions < ::RuboCop::Cop::Base
+      class SpecificActions < RuboCop::Cop::Base
         MSG = "Prefer `%<good_action>s` over `find('%<selector>s').click`."
         RESTRICT_ON_SEND = %i[click].freeze
         SPECIFIC_ACTION = {
@@ -33,6 +33,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if node.arguments? || node.block_node
+
           click_on_selector(node.receiver) do |arg|
             next unless supported_selector?(arg)
             # Always check the last selector in the case of multiple selectors
@@ -51,7 +53,7 @@ module RuboCop
         private
 
         def specific_action(selector)
-          SPECIFIC_ACTION[last_selector(selector)]
+          SPECIFIC_ACTION[selector]
         end
 
         def replaceable?(node, arg, action)
@@ -71,7 +73,10 @@ module RuboCop
         end
 
         def last_selector(arg)
-          arg.split.last[/^\w+/, 0]
+          without_attributes = arg.gsub(/\[(?:'[^']*'|"[^"]*"|[^\]])*\]/) do |m|
+            m.gsub(/\s/, '')
+          end
+          without_attributes.split.last&.[](/^[\w-]+/, 0)
         end
 
         def offense_range(node, receiver)