rubocop-capybara 3.0.0 → 3.1.0

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Enforces use of `Element#[]` instead of `native.attribute`.
+      #
+      # Only calls on Capybara finder chains are checked.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because attribute values may
+      #   differ between the driver API and Capybara's `Element#[]`.
+      #
+      # @example
+      #   # bad
+      #   find('.item').native.attribute(:id)
+      #   page.find('.item').native.attribute('aria-label')
+      #
+      #   # good
+      #   find('.item')[:id]
+      #   page.find('.item')['aria-label']
+      #
+      class NativeAttribute < RuboCop::Cop::Base
+        extend AutoCorrector
+        include CapybaraHelp
+
+        MSG = 'Use `Element#[]` instead of driver-specific `native.attribute`.'
+        RESTRICT_ON_SEND = %i[attribute].freeze
+
+        # @!method native_attribute(node)
+        def_node_matcher :native_attribute, <<~PATTERN
+          (call
+            $(call #element_finder? :native)
+            :attribute
+            $({str sym} _))
+        PATTERN
+
+        # @!method element_finder?(node)
+        def_node_matcher :element_finder?, <<~PATTERN
+          {#capybara_receiver?
+           (call #capybara_receiver?
+             {:ancestor :find :find_button :find_by_id
+              :find_field :find_link :first :sibling} ...)
+           (any_block #element_finder? ...)
+           (begin #element_finder?)}
+        PATTERN
+
+        def on_send(node)
+          native_attribute(node) do |native, attribute|
+            next unless native.receiver
+
+            add_offense(node) do |corrector|
+              next if attribute.str_type? && attribute.heredoc?
+
+              correct_attribute(corrector, node, native, attribute)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def correct_attribute(corrector, node, native, attribute)
+          range = node.source_range.with(begin_pos: native.loc.dot.begin_pos)
+          return if processed_source.comments.any? do |comment|
+            range.contains?(comment.source_range)
+          end
+
+          safe_navigation = native.csend_type? && node.csend_type?
+          template = safe_navigation ? '&.[](%s)' : '[%s]'
+          corrector.replace(range, format(template, attribute.source))
+        end
+      end
+    end
+  end
+end

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

@@ -22,13 +22,13 @@ module RuboCop
       #   end
       #
       #   # good
-      #   within '#foo' do
+      #   within :id, 'foo' do
       #     # ...
       #   end
       #
-      class RedundantWithinFind < ::RuboCop::Cop::Base
-        include CssSelector
+      class RedundantWithinFind < RuboCop::Cop::Base
         extend AutoCorrector
+
         MSG = 'Redundant `within %<method>s(...)` call detected.'
         RESTRICT_ON_SEND = %i[within].freeze
         FIND_METHODS = Set.new(%i[find find_by_id]).freeze
@@ -41,8 +41,10 @@ module RuboCop
 
         def on_send(node)
           within_find(node) do |find_node|
+            replacement = replaced(find_node)
+
             add_offense(find_node, message: msg(find_node)) do |corrector|
-              corrector.replace(find_node, replaced(find_node))
+              corrector.replace(find_node, replacement) if replacement
             end
           end
         end
@@ -54,24 +56,11 @@ module RuboCop
         end
 
         def replaced(node)
-          unless node.method?(:find_by_id)
-            return node.arguments.map(&:source).join(', ')
-          end
-
-          if node.first_argument.str_type?
-            build_escaped_selector(node.first_argument, node)
-          else
-            node.arguments.map(&:source).join(', ')
-              .sub(/\A(["'])/, '\1#')
-          end
-        end
-
-        def build_escaped_selector(first_arg, node)
-          quote = first_arg.source[0]
-          escaped_id = CssSelector.css_escape(first_arg.value, quote)
-          rest_args = node.arguments.drop(1).map(&:source)
+          return unless node.first_argument
+          return if node.arguments.any?(&:block_pass_type?)
 
-          ["#{quote}##{escaped_id}#{quote}", *rest_args].join(', ')
+          args = node.arguments.map(&:source).join(', ')
+          node.method?(:find_by_id) ? ":id, #{args}" : args
         end
       end
     end

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

@@ -25,9 +25,9 @@ module RuboCop
         #   expect(page).to have_current_path('/callback', ignore_query: true)
         #
         #   # bad (does not support autocorrection when `match` with a variable)
-        #   expect(page).to match(variable)
+        #   expect(current_path).to match(variable)
         #
-        class CurrentPathExpectation < ::RuboCop::Cop::Base
+        class CurrentPathExpectation < RuboCop::Cop::Base
           extend AutoCorrector
           include RangeHelp
 
@@ -79,8 +79,11 @@ module RuboCop
             end
 
             regexp_node_matcher(node.parent) do |to_sym, matcher_node, regexp|
+              regexp_expr = regexp_node_to_regexp_expr(regexp)
+              next unless regexp_expr
+
               rewrite_expectation(corrector, node, to_sym, matcher_node)
-              convert_regexp_node_to_literal(corrector, matcher_node, regexp)
+              corrector.replace(matcher_node.first_argument, regexp_expr)
             end
           end
 
@@ -94,22 +97,19 @@ module RuboCop
                              end
             corrector.replace(matcher_node.loc.selector, matcher_method)
             add_argument_parentheses(corrector, matcher_node.first_argument)
-            add_ignore_query_options(corrector, node, matcher_node)
-          end
-
-          def convert_regexp_node_to_literal(corrector, matcher_node,
-                                             regexp_node)
-            str_node = matcher_node.first_argument
-            regexp_expr = regexp_node_to_regexp_expr(regexp_node)
-            corrector.replace(str_node, regexp_expr)
+            add_ignore_query_options(corrector, node)
           end
 
           def regexp_node_to_regexp_expr(regexp_node)
             if regexp_node.xstr_type?
               "/\#{`#{regexp_node.value.value}`}/"
             else
+              return if regexp_node.value.match?(/#[{@$]/)
+
               Regexp.new(regexp_node.value).inspect
             end
+          rescue RegexpError
+            nil
           end
 
           def add_argument_parentheses(corrector, arg_node)
@@ -129,11 +129,8 @@ module RuboCop
 
           # `have_current_path` with no options will include the querystring
           # while `page.current_path` does not.
-          # This ensures the option `ignore_query: true` is added
-          # except when `match` matcher.
-          def add_ignore_query_options(corrector, node, matcher_node)
-            return if matcher_node.method?(:match)
-
+          # This ensures the option `ignore_query: true` is added.
+          def add_ignore_query_options(corrector, node)
             expectation_node = node.parent.last_argument
             expectation_last_child = expectation_node.children.last
             corrector.insert_after(expectation_last_child,

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Checks expectations on `current_url` that bypass Capybara's waiting.
+        #
+        # `have_current_path` can match full URLs and waits for navigation.
+        # A regexp needs `url: true` so it matches the full URL, not just the
+        # path. Autocorrection is unsafe because URL parsing and waiting change
+        # comparison behavior.
+        # Dynamic `match` patterns and `include`, `start_with`, and `end_with`
+        # are reported without autocorrection.
+        #
+        # @example
+        #   # bad
+        #   expect(page.current_url).to eq('https://example.com/login')
+        #   expect(current_url).to match(%r{/login})
+        #   expect(current_url).to match('login')
+        #   expect(page.current_url).to include('/login')
+        #
+        #   # good
+        #   expect(page).to have_current_path('https://example.com/login')
+        #   expect(page).to have_current_path(%r{/login}, url: true)
+        #   expect(page).to have_current_path(/login/, url: true)
+        #
+        class CurrentUrlExpectation < RuboCop::Cop::Base
+          extend AutoCorrector
+
+          MSG = 'Use `have_current_path` on `page` to wait for the URL.'
+          RESTRICT_ON_SEND = %i[expect].freeze
+          PATH_MATCHERS = {
+            to: 'have_current_path',
+            not_to: 'have_no_current_path',
+            to_not: 'have_no_current_path'
+          }.freeze
+
+          # @!method url_actual(node)
+          def_node_matcher :url_actual, <<~PATTERN
+            (send nil? :expect
+              $(send {(send nil? :page) nil?} :current_url))
+          PATTERN
+
+          # @!method supported_matcher?(node)
+          def_node_matcher :supported_matcher?, <<~PATTERN
+            {(send nil? :eq _)
+             (send nil? :match _)
+             (send nil? {:include :start_with :end_with} (str _))}
+          PATTERN
+
+          # @!method expectation_runner?(node)
+          def_node_matcher :expectation_runner?, <<~PATTERN
+            (send (send nil? :expect _) {:to :not_to :to_not} _)
+          PATTERN
+
+          def self.autocorrect_incompatible_with
+            [Style::TrailingCommaInArguments]
+          end
+
+          def on_send(node)
+            actual = url_actual(node)
+            return unless actual
+
+            runner = node.parent
+            return unless expectation_runner?(runner)
+
+            matcher = runner.first_argument
+            return unless supported_matcher?(matcher)
+
+            register_offense(node.loc.selector, actual, runner, matcher)
+          end
+          alias on_csend on_send
+
+          private
+
+          def register_offense(range, actual, runner, matcher)
+            regexp = if matcher.method?(:match)
+                       regexp_source(matcher.first_argument)
+                     end
+            unless correctable_matcher?(matcher, regexp)
+              return add_offense(range)
+            end
+
+            add_offense(range) do |corrector|
+              autocorrect(corrector, actual, runner, matcher, regexp)
+            end
+          end
+
+          def correctable_matcher?(matcher, regexp)
+            return true if matcher.method?(:eq)
+            return false unless matcher.method?(:match)
+
+            matcher.first_argument.regexp_type? || regexp
+          end
+
+          def regexp_source(argument)
+            return unless argument.str_type?
+            return if argument.value.match?(/#[{@$]/)
+
+            Regexp.new(argument.value).inspect
+          rescue RegexpError
+            nil
+          end
+
+          def autocorrect(corrector, actual, runner, matcher, regexp)
+            corrector.replace(actual, 'page')
+            unless runner.method?(:to)
+              corrector.replace(runner.loc.selector, 'to')
+            end
+            corrector.replace(matcher.loc.selector,
+                              PATH_MATCHERS.fetch(runner.method_name))
+            return unless matcher.method?(:match)
+
+            corrector.replace(matcher.first_argument, regexp) if regexp
+            corrector.insert_after(matcher.first_argument, ', url: true')
+          end
+        end
+      end
+    end
+  end
+end

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