actionpack 6.0.0

data/lib/action_dispatch/system_testing/browser.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module SystemTesting
+    class Browser # :nodoc:
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def type
+        case name
+        when :headless_chrome
+          :chrome
+        when :headless_firefox
+          :firefox
+        else
+          name
+        end
+      end
+
+      def options
+        case name
+        when :headless_chrome
+          headless_chrome_browser_options
+        when :headless_firefox
+          headless_firefox_browser_options
+        end
+      end
+
+      def capabilities
+        @option ||=
+          case type
+          when :chrome
+            ::Selenium::WebDriver::Chrome::Options.new
+          when :firefox
+            ::Selenium::WebDriver::Firefox::Options.new
+          end
+      end
+
+      # driver_path can be configured as a proc. The webdrivers gem uses this
+      # proc to update web drivers. Running this proc early allows us to only
+      # update the webdriver once and avoid race conditions when using
+      # parallel tests.
+      def preload
+        case type
+        when :chrome
+          if ::Selenium::WebDriver::Service.respond_to? :driver_path=
+            ::Selenium::WebDriver::Chrome::Service.driver_path.try(:call)
+          else
+            # Selenium <= v3.141.0
+            ::Selenium::WebDriver::Chrome.driver_path
+          end
+        when :firefox
+          if ::Selenium::WebDriver::Service.respond_to? :driver_path=
+            ::Selenium::WebDriver::Firefox::Service.driver_path.try(:call)
+          else
+            # Selenium <= v3.141.0
+            ::Selenium::WebDriver::Firefox.driver_path
+          end
+        end
+      end
+
+      private
+        def headless_chrome_browser_options
+          capabilities.args << "--headless"
+          capabilities.args << "--disable-gpu" if Gem.win_platform?
+
+          capabilities
+        end
+
+        def headless_firefox_browser_options
+          capabilities.args << "-headless"
+
+          capabilities
+        end
+    end
+  end
+end

data/lib/action_dispatch/system_testing/driver.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module SystemTesting
+    class Driver # :nodoc:
+      def initialize(name, **options, &capabilities)
+        @name = name
+        @browser = Browser.new(options[:using])
+        @screen_size = options[:screen_size]
+        @options = options[:options]
+        @capabilities = capabilities
+
+        @browser.preload
+      end
+
+      def use
+        register if registerable?
+
+        setup
+      end
+
+      private
+        def registerable?
+          [:selenium, :poltergeist, :webkit].include?(@name)
+        end
+
+        def register
+          define_browser_capabilities(@browser.capabilities)
+
+          Capybara.register_driver @name do |app|
+            case @name
+            when :selenium then register_selenium(app)
+            when :poltergeist then register_poltergeist(app)
+            when :webkit then register_webkit(app)
+            end
+          end
+        end
+
+        def define_browser_capabilities(capabilities)
+          @capabilities.call(capabilities) if @capabilities
+        end
+
+        def browser_options
+          @options.merge(options: @browser.options).compact
+        end
+
+        def register_selenium(app)
+          Capybara::Selenium::Driver.new(app, { browser: @browser.type }.merge(browser_options)).tap do |driver|
+            driver.browser.manage.window.size = Selenium::WebDriver::Dimension.new(*@screen_size)
+          end
+        end
+
+        def register_poltergeist(app)
+          Capybara::Poltergeist::Driver.new(app, @options.merge(window_size: @screen_size))
+        end
+
+        def register_webkit(app)
+          Capybara::Webkit::Driver.new(app, Capybara::Webkit::Configuration.to_hash.merge(@options)).tap do |driver|
+            driver.resize_window_to(driver.current_window_handle, *@screen_size)
+          end
+        end
+
+        def setup
+          Capybara.current_driver = @name
+        end
+    end
+  end
+end

data/lib/action_dispatch/system_testing/server.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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,97 @@
+# frozen_string_literal: true
+
+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.
+        #
+        # The screenshot will be displayed in your console, if supported.
+        #
+        # You can 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
+          save_image
+          puts display_image
+        end
+
+        # Takes a screenshot of the current page in the browser if the test
+        # failed.
+        #
+        # +take_failed_screenshot+ is included in <tt>application_system_test_case.rb</tt>
+        # that is generated with the application. To take screenshots when a test
+        # fails add +take_failed_screenshot+ to the teardown block before clearing
+        # sessions.
+        def take_failed_screenshot
+          take_screenshot if failed? && supports_screenshot?
+        end
+
+        private
+          def image_name
+            name = method_name[0...225]
+            failed? ? "failures_#{name}" : name
+          end
+
+          def image_path
+            @image_path ||= absolute_image_path.to_s
+          end
+
+          def absolute_image_path
+            Rails.root.join("tmp/screenshots/#{image_name}.png")
+          end
+
+          def save_image
+            page.save_screenshot(absolute_image_path)
+          end
+
+          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 display_image
+            message = +"[Screenshot]: #{image_path}\n"
+
+            case 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,33 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module SystemTesting
+    module TestHelpers
+      module SetupAndTeardown # :nodoc:
+        DEFAULT_HOST = "http://127.0.0.1"
+
+        def host!(host)
+          super
+          Capybara.app_host = host
+        end
+
+        def before_setup
+          host! DEFAULT_HOST
+          super
+        end
+
+        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/system_testing/test_helpers/undef_methods.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module SystemTesting
+    module TestHelpers
+      module UndefMethods # :nodoc:
+        extend ActiveSupport::Concern
+        included do
+          METHODS = %i(get post put patch delete).freeze
+
+          METHODS.each do |verb|
+            undef_method verb
+          end
+
+          def method_missing(method, *args, &block)
+            if METHODS.include?(method)
+              raise NoMethodError, "System tests cannot make direct requests via ##{method}; use #visit and #click_on instead. See http://www.rubydoc.info/github/teamcapybara/capybara/master#The_DSL for more information."
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_dispatch/testing/assertion_response.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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::SYMBOL_TO_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.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails-dom-testing"
+
+module ActionDispatch
+  module Assertions
+    autoload :ResponseAssertions, "action_dispatch/testing/assertions/response"
+    autoload :RoutingAssertions, "action_dispatch/testing/assertions/routing"
+
+    extend ActiveSupport::Concern
+
+    include ResponseAssertions
+    include RoutingAssertions
+    include Rails::Dom::Testing::Assertions
+
+    def html_document
+      @html_document ||= if @response.media_type.to_s.end_with?("xml")
+        Nokogiri::XML::Document.parse(@response.body)
+      else
+        Nokogiri::HTML::Document.parse(@response.body)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Assertions
+    # 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
+      #
+      # 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.
+      #
+      #   # Asserts that the response was a redirection
+      #   assert_response :redirect
+      #
+      #   # Asserts that the response code was status code 401 (unauthorized)
+      #   assert_response 401
+      def assert_response(type, message = nil)
+        message ||= generate_response_message(type)
+
+        if RESPONSE_PREDICATES.keys.include?(type)
+          assert @response.send(RESPONSE_PREDICATES[type]), message
+        else
+          assert_equal AssertionResponse.new(type).code, @response.response_code, message
+        end
+      end
+
+      # Asserts 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 redirection was to the "index" action on the WeblogController
+      #   assert_redirected_to controller: "weblog", action: "index"
+      #
+      #   # Asserts that the redirection was to the named route login_url
+      #   assert_redirected_to login_url
+      #
+      #   # 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
+
+        redirect_is       = normalize_argument_to_redirection(@response.location)
+        redirect_expected = normalize_argument_to_redirection(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
+      end
+
+      private
+        # Proxy to to_param if the object will respond to it.
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+
+        def normalize_argument_to_redirection(fragment)
+          if Regexp === fragment
+            fragment
+          else
+            handle = @controller || ActionController::Redirecting
+            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.values.include?("#{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