actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_dispatch/system_testing/browser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    class Browser # :nodoc:
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+        set_default_options
+      end
+
+      def type
+        case name
+        when :headless_chrome
+          :chrome
+        when :headless_firefox
+          :firefox
+        else
+          name
+        end
+      end
+
+      def options
+        @options ||=
+          case type
+          when :chrome
+            ::Selenium::WebDriver::Chrome::Options.new
+          when :firefox
+            ::Selenium::WebDriver::Firefox::Options.new
+          end
+      end
+
+      def configure
+        yield options if block_given?
+      end
+
+      # driver_path is lazily initialized by default. Eagerly set it to avoid race
+      # conditions when using parallel tests.
+      def preload
+        case type
+        when :chrome
+          resolve_driver_path(::Selenium::WebDriver::Chrome)
+        when :firefox
+          resolve_driver_path(::Selenium::WebDriver::Firefox)
+        end
+      end
+
+      private
+        def set_default_options
+          case name
+          when :headless_chrome
+            set_headless_chrome_browser_options
+          when :headless_firefox
+            set_headless_firefox_browser_options
+          end
+        end
+
+        def set_headless_chrome_browser_options
+          configure do |capabilities|
+            capabilities.add_argument("--headless")
+            capabilities.add_argument("--disable-gpu") if Gem.win_platform?
+          end
+        end
+
+        def set_headless_firefox_browser_options
+          configure do |capabilities|
+            capabilities.add_argument("-headless")
+          end
+        end
+
+        def resolve_driver_path(namespace)
+          # The path method has been deprecated in 4.20.0
+          if Gem::Version.new(::Selenium::WebDriver::VERSION) >= Gem::Version.new("4.20.0")
+            namespace::Service.driver_path = ::Selenium::WebDriver::DriverFinder.new(options, namespace::Service.new).driver_path
+          else
+            namespace::Service.driver_path = ::Selenium::WebDriver::DriverFinder.path(options, namespace::Service)
+          end
+        end
+    end
+  end
+end

data/lib/action_dispatch/system_testing/driver.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    class Driver # :nodoc:
+      attr_reader :name
+
+      def initialize(driver_type, **options, &capabilities)
+        @driver_type = driver_type
+        @screen_size = options[:screen_size]
+        @options = options[:options] || {}
+        @name = @options.delete(:name) || driver_type
+        @capabilities = capabilities
+
+        if driver_type == :selenium
+          gem "selenium-webdriver", ">= 4.0.0"
+          require "selenium/webdriver"
+          @browser = Browser.new(options[:using])
+          @browser.preload unless @options[:browser] == :remote
+        else
+          @browser = nil
+        end
+      end
+
+      def use
+        register if registerable?
+
+        setup
+      end
+
+      private
+        def registerable?
+          [:selenium, :cuprite, :rack_test, :playwright].include?(@driver_type)
+        end
+
+        def register
+          @browser&.configure(&@capabilities)
+
+          Capybara.register_driver name do |app|
+            case @driver_type
+            when :selenium then register_selenium(app)
+            when :cuprite then register_cuprite(app)
+            when :rack_test then register_rack_test(app)
+            when :playwright then register_playwright(app)
+            end
+          end
+        end
+
+        def browser_options
+          @options.merge(options: @browser.options).compact
+        end
+
+        def register_selenium(app)
+          Capybara::Selenium::Driver.new(app, browser: @browser.type, **browser_options).tap do |driver|
+            driver.browser.manage.window.size = Selenium::WebDriver::Dimension.new(*@screen_size)
+          end
+        end
+
+        def register_cuprite(app)
+          Capybara::Cuprite::Driver.new(app, @options.merge(window_size: @screen_size))
+        end
+
+        def register_rack_test(app)
+          Capybara::RackTest::Driver.new(app, respect_data_method: true, **@options)
+        end
+
+        def register_playwright(app)
+          screen = { width: @screen_size[0], height: @screen_size[1] } if @screen_size
+          options = {
+            screen: screen,
+            viewport: screen,
+            **@options
+          }.compact
+
+          Capybara::Playwright::Driver.new(app, **options)
+        end
+
+        def setup
+          Capybara.current_driver = name
+        end
+    end
+  end
+end

data/lib/action_dispatch/system_testing/server.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    class Server # :nodoc:
+      class << self
+        attr_accessor :silence_puma
+      end
+
+      self.silence_puma = false
+
+      def run
+        setup
+      end
+
+      private
+        def setup
+          set_server
+          set_port
+        end
+
+        def set_server
+          Capybara.server = :puma, { Silent: self.class.silence_puma } if Capybara.server == Capybara.servers[:default]
+        end
+
+        def set_port
+          Capybara.always_include_port = true
+        end
+    end
+  end
+end

data/lib/action_dispatch/system_testing/test_helpers/screenshot_helper.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    module TestHelpers
+      # Screenshot helper for system testing.
+      module ScreenshotHelper
+        # Takes a screenshot of the current page in the browser.
+        #
+        # `take_screenshot` can be used at any point in your system tests to take a
+        # screenshot of the current state. This can be useful for debugging or
+        # automating visual testing. You can take multiple screenshots per test to
+        # investigate changes at different points during your test. These will be named
+        # with a sequential prefix (or 'failed' for failing tests)
+        #
+        # The default screenshots directory is `tmp/screenshots` but you can set a
+        # different one with `Capybara.save_path`
+        #
+        # You can use the `html` argument or set the
+        # `RAILS_SYSTEM_TESTING_SCREENSHOT_HTML` environment variable to save the HTML
+        # from the page that is being screenshotted so you can investigate the elements
+        # on the page at the time of the screenshot
+        #
+        # You can use the `screenshot` argument or set the
+        # `RAILS_SYSTEM_TESTING_SCREENSHOT` environment variable to control the output.
+        # Possible values are:
+        #     `simple` (default)
+        # :       Only displays the screenshot path. This is the default value.
+        #
+        #     `inline`
+        # :       Display the screenshot in the terminal using the iTerm image protocol
+        #         (https://iterm2.com/documentation-images.html).
+        #
+        #     `artifact`
+        # :       Display the screenshot in the terminal, using the terminal artifact
+        #         format (https://buildkite.github.io/terminal-to-html/inline-images/).
+        #
+        #
+        def take_screenshot(html: false, screenshot: nil)
+          showing_html = html || html_from_env?
+
+          increment_unique
+          save_html if showing_html
+          save_image
+          show display_image(html: showing_html, screenshot_output: screenshot)
+        end
+
+        # Takes a screenshot of the current page in the browser if the test failed.
+        #
+        # `take_failed_screenshot` is called during system test teardown.
+        def take_failed_screenshot
+          return unless failed? && supports_screenshot? && Capybara::Session.instance_created?
+
+          take_screenshot
+          metadata[:failure_screenshot_path] = relative_image_path if Minitest::Runnable.method_defined?(:metadata)
+        end
+
+        private
+          attr_accessor :_screenshot_counter
+
+          def html_from_env?
+            ENV["RAILS_SYSTEM_TESTING_SCREENSHOT_HTML"] == "1"
+          end
+
+          def increment_unique
+            @_screenshot_counter ||= 0
+            @_screenshot_counter += 1
+          end
+
+          def unique
+            failed? ? "failures" : (_screenshot_counter || 0).to_s
+          end
+
+          def image_name
+            sanitized_method_name = method_name.gsub(/[^\w]+/, "-")
+            name = "#{unique}_#{sanitized_method_name}"
+            name[0...225]
+          end
+
+          def image_path
+            absolute_image_path.to_s
+          end
+
+          def html_path
+            absolute_html_path.to_s
+          end
+
+          def absolute_path
+            Rails.root.join(screenshots_dir, image_name)
+          end
+
+          def screenshots_dir
+            Capybara.save_path.presence || "tmp/screenshots"
+          end
+
+          def absolute_image_path
+            "#{absolute_path}.png"
+          end
+
+          def relative_image_path
+            "#{absolute_path.relative_path_from(Rails.root)}.png"
+          end
+
+          def absolute_html_path
+            "#{absolute_path}.html"
+          end
+
+          # rubocop:disable Lint/Debugger
+          def save_html
+            page.save_page(absolute_html_path)
+          end
+
+          def save_image
+            page.save_screenshot(absolute_image_path)
+          end
+          # rubocop:enable Lint/Debugger
+
+          def output_type
+            # Environment variables have priority
+            output_type = ENV["RAILS_SYSTEM_TESTING_SCREENSHOT"] || ENV["CAPYBARA_INLINE_SCREENSHOT"]
+
+            # Default to outputting a path to the screenshot
+            output_type ||= "simple"
+
+            output_type
+          end
+
+          def show(img)
+            puts img
+          end
+
+          def display_image(html:, screenshot_output:)
+            message = +"[Screenshot Image]: #{image_path}\n"
+            message << +"[Screenshot HTML]: #{html_path}\n" if html
+
+            case screenshot_output || output_type
+            when "artifact"
+              message << "\e]1338;url=artifact://#{absolute_image_path}\a\n"
+            when "inline"
+              name = inline_base64(File.basename(absolute_image_path))
+              image = inline_base64(File.read(absolute_image_path))
+              message << "\e]1337;File=name=#{name};height=400px;inline=1:#{image}\a\n"
+            end
+
+            message
+          end
+
+          def inline_base64(path)
+            Base64.strict_encode64(path)
+          end
+
+          def failed?
+            !passed? && !skipped?
+          end
+
+          def supports_screenshot?
+            Capybara.current_driver != :rack_test
+          end
+      end
+    end
+  end
+end

data/lib/action_dispatch/system_testing/test_helpers/setup_and_teardown.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module SystemTesting
+    module TestHelpers
+      module SetupAndTeardown # :nodoc:
+        def before_teardown
+          take_failed_screenshot
+        ensure
+          super
+        end
+
+        def after_teardown
+          Capybara.reset_sessions!
+        ensure
+          super
+        end
+      end
+    end
+  end
+end

data/lib/action_dispatch/testing/assertion_response.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  # This is a class that abstracts away an asserted response. It purposely does
+  # not inherit from Response because it doesn't need it. That means it does not
+  # have headers or a body.
+  class AssertionResponse
+    attr_reader :code, :name
+
+    GENERIC_RESPONSE_CODES = { # :nodoc:
+      success: "2XX",
+      missing: "404",
+      redirect: "3XX",
+      error: "5XX"
+    }
+
+    # Accepts a specific response status code as an Integer (404) or String ('404')
+    # or a response status range as a Symbol pseudo-code (:success, indicating any
+    # 200-299 status code).
+    def initialize(code_or_name)
+      if code_or_name.is_a?(Symbol)
+        @name = code_or_name
+        @code = code_from_name(code_or_name)
+      else
+        @name = name_from_code(code_or_name)
+        @code = code_or_name
+      end
+
+      raise ArgumentError, "Invalid response name: #{name}" if @code.nil?
+      raise ArgumentError, "Invalid response code: #{code}" if @name.nil?
+    end
+
+    def code_and_name
+      "#{code}: #{name}"
+    end
+
+    private
+      def code_from_name(name)
+        GENERIC_RESPONSE_CODES[name] || Rack::Utils.status_code(name)
+      end
+
+      def name_from_code(code)
+        GENERIC_RESPONSE_CODES.invert[code] || Rack::Utils::HTTP_STATUS_CODES[code]
+      end
+  end
+end

data/lib/action_dispatch/testing/assertions/response.rb

@@ -1,63 +1,71 @@
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionDispatch
   module Assertions
-    # A small suite of assertions that test responses from \Rails applications.
+    # A small suite of assertions that test responses from Rails applications.
     module ResponseAssertions
+      RESPONSE_PREDICATES = { # :nodoc:
+        success:  :successful?,
+        missing:  :not_found?,
+        redirect: :redirection?,
+        error:    :server_error?,
+      }
+
       # Asserts that the response is one of the following types:
       #
-      # * <tt>:success</tt>   - Status code was in the 200-299 range
-      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
-      # * <tt>:missing</tt>   - Status code was 404
-      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      # *   `:success`   - Status code was in the 200-299 range
+      # *   `:redirect`  - Status code was in the 300-399 range
+      # *   `:missing`   - Status code was 404
+      # *   `:error`     - Status code was in the 500-599 range
+      #
       #
-      # You can also pass an explicit status number like <tt>assert_response(501)</tt>
-      # or its symbolic equivalent <tt>assert_response(:not_implemented)</tt>.
-      # See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list.
+      # You can also pass an explicit status number like `assert_response(501)` or its
+      # symbolic equivalent `assert_response(:not_implemented)`. See
+      # `Rack::Utils::SYMBOL_TO_STATUS_CODE` for a full list.
       #
-      #   # assert that the response was a redirection
-      #   assert_response :redirect
+      #     # Asserts that the response was a redirection
+      #     assert_response :redirect
       #
-      #   # assert that the response code was status code 401 (unauthorized)
-      #   assert_response 401
+      #     # Asserts that the response code was status code 401 (unauthorized)
+      #     assert_response 401
       def assert_response(type, message = nil)
-        message ||= "Expected response to be a <#{type}>, but was <#{@response.response_code}>"
+        message ||= generate_response_message(type)
 
-        if Symbol === type
-          if [:success, :missing, :redirect, :error].include?(type)
-            assert @response.send("#{type}?"), message
-          else
-            code = Rack::Utils::SYMBOL_TO_STATUS_CODE[type]
-            if code.nil?
-              raise ArgumentError, "Invalid response type :#{type}"
-            end
-            assert_equal code, @response.response_code, message
-          end
+        if RESPONSE_PREDICATES.key?(type)
+          assert @response.public_send(RESPONSE_PREDICATES[type]), message
         else
-          assert_equal type, @response.response_code, message
+          assert_equal AssertionResponse.new(type).code, @response.response_code, message
         end
       end
 
-      # Assert that the redirection options passed in match those of the redirect called in the latest action.
-      # This match can be partial, such that <tt>assert_redirected_to(controller: "weblog")</tt> will also
-      # match the redirection of <tt>redirect_to(controller: "weblog", action: "show")</tt> and so on.
+      # Asserts that the response is a redirect to a URL matching the given options.
       #
-      #   # assert that the redirection was to the "index" action on the WeblogController
-      #   assert_redirected_to controller: "weblog", action: "index"
+      #     # Asserts that the redirection was to the "index" action on the WeblogController
+      #     assert_redirected_to controller: "weblog", action: "index"
       #
-      #   # assert that the redirection was to the named route login_url
-      #   assert_redirected_to login_url
+      #     # Asserts that the redirection was to the named route login_url
+      #     assert_redirected_to login_url
       #
-      #   # assert that the redirection was to the url for @customer
-      #   assert_redirected_to @customer
+      #     # Asserts that the redirection was to the URL for @customer
+      #     assert_redirected_to @customer
       #
-      #   # asserts that the redirection matches the regular expression
-      #   assert_redirected_to %r(\Ahttp://example.org)
-      def assert_redirected_to(options = {}, message=nil)
-        assert_response(:redirect, message)
-        return true if options === @response.location
+      #     # Asserts that the redirection matches the regular expression
+      #     assert_redirected_to %r(\Ahttp://example.org)
+      #
+      #     # Asserts that the redirection has the HTTP status code 301 (Moved
+      #     # Permanently).
+      #     assert_redirected_to "/some/path", status: :moved_permanently
+      def assert_redirected_to(url_options = {}, options = {}, message = nil)
+        options, message = {}, options unless options.is_a?(Hash)
+
+        status = options[:status] || :redirect
+        assert_response(status, message)
+        return true if url_options === @response.location
 
         redirect_is       = normalize_argument_to_redirection(@response.location)
-        redirect_expected = normalize_argument_to_redirection(options)
+        redirect_expected = normalize_argument_to_redirection(url_options)
 
         message ||= "Expected response to be a redirect to <#{redirect_expected}> but was a redirect to <#{redirect_is}>"
         assert_operator redirect_expected, :===, redirect_is, message
@@ -77,6 +85,30 @@ module ActionDispatch
             handle._compute_redirect_to_location(@request, fragment)
           end
         end
+
+        def generate_response_message(expected, actual = @response.response_code)
+          (+"Expected response to be a <#{code_with_name(expected)}>,"\
+          " but was a <#{code_with_name(actual)}>").concat(location_if_redirected).concat(response_body_if_short)
+        end
+
+        def response_body_if_short
+          return "" if @response.body.size > 500
+          "\nResponse body: #{@response.body}"
+        end
+
+        def location_if_redirected
+          return "" unless @response.redirection? && @response.location.present?
+          location = normalize_argument_to_redirection(@response.location)
+          " redirect to <#{location}>"
+        end
+
+        def code_with_name(code_or_name)
+          if RESPONSE_PREDICATES.value?("#{code_or_name}?".to_sym)
+            code_or_name = RESPONSE_PREDICATES.invert["#{code_or_name}?".to_sym]
+          end
+
+          AssertionResponse.new(code_or_name).code_and_name
+        end
     end
   end
 end