actionpack 4.2.8 → 5.2.4.2

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,96 @@
+# 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/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
+            failed? ? "failures_#{method_name}" : method_name
+          end
+
+          def image_path
+            @image_path ||= absolute_image_path.relative_path_from(Pathname.pwd).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".dup
+
+            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.encode64(path).gsub("\n", "")
+          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,31 @@
+# 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 after_teardown
+          begin
+            take_failed_screenshot
+          ensure
+            Capybara.reset_sessions!
+          end
+        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

@@ -1,9 +1,11 @@
-require 'rails-dom-testing'
+# 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'
+    autoload :ResponseAssertions, "action_dispatch/testing/assertions/response"
+    autoload :RoutingAssertions, "action_dispatch/testing/assertions/routing"
 
     extend ActiveSupport::Concern
 
@@ -12,7 +14,7 @@ module ActionDispatch
     include Rails::Dom::Testing::Assertions
 
     def html_document
-      @html_document ||= if @response.content_type.to_s =~ /xml$/
+      @html_document ||= if @response.content_type.to_s.end_with?("xml")
         Nokogiri::XML::Document.parse(@response.body)
       else
         Nokogiri::HTML::Document.parse(@response.body)

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

@@ -1,8 +1,16 @@
+# 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
@@ -14,45 +22,37 @@ module ActionDispatch
       # or its symbolic equivalent <tt>assert_response(:not_implemented)</tt>.
       # See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list.
       #
-      #   # assert that the response was a redirection
+      #   # Asserts that the response was a redirection
       #   assert_response :redirect
       #
-      #   # assert that the response code was status code 401 (unauthorized)
+      #   # 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.keys.include?(type)
+          assert @response.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.
+      # 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.
       #
-      #   # assert that the redirection was to the "index" action on the WeblogController
+      #   # 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
+      #   # 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
+      #   # Asserts that the redirection was to the URL for @customer
       #   assert_redirected_to @customer
       #
-      #   # asserts that the redirection matches the regular expression
+      #   # Asserts that the redirection matches the regular expression
       #   assert_redirected_to %r(\Ahttp://example.org)
-      def assert_redirected_to(options = {}, message=nil)
+      def assert_redirected_to(options = {}, message = nil)
         assert_response(:redirect, message)
         return true if options === @response.location
 
@@ -77,6 +77,31 @@ 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)}>"
+            .dup.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

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

@@ -1,7 +1,9 @@
-require 'uri'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/string/access'
-require 'action_controller/metal/exceptions'
+# frozen_string_literal: true
+
+require "uri"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/string/access"
+require "action_controller/metal/exceptions"
 
 module ActionDispatch
   module Assertions
@@ -14,14 +16,14 @@ module ActionDispatch
       # requiring a specific HTTP method. The hash should contain a :path with the incoming request path
       # and a :method containing the required HTTP verb.
       #
-      #   # assert that POSTing to /items will call the create action on ItemsController
+      #   # Asserts that POSTing to /items will call the create action on ItemsController
       #   assert_recognizes({controller: 'items', action: 'create'}, {path: 'items', method: :post})
       #
       # You can also pass in +extras+ with a hash containing URL parameters that would normally be in the query string. This can be used
-      # to assert that values in the query string string will end up in the params hash correctly. To test query strings you must use the
-      # extras argument, appending the query string on the path directly will not work. For example:
+      # to assert that values in the query string will end up in the params hash correctly. To test query strings you must use the extras
+      # argument because appending the query string on the path directly will not work. For example:
       #
-      #   # assert that a path of '/items/list/1?view=print' returns the correct options
+      #   # Asserts that a path of '/items/list/1?view=print' returns the correct options
       #   assert_recognizes({controller: 'items', action: 'list', id: '1', view: 'print'}, 'items/list/1', { view: "print" })
       #
       # The +message+ parameter allows you to pass in an error message that is displayed upon failure.
@@ -37,7 +39,7 @@ module ActionDispatch
       #
       #   # Test a custom route
       #   assert_recognizes({controller: 'items', action: 'show', id: '1'}, 'view/item1')
-      def assert_recognizes(expected_options, path, extras={}, msg=nil)
+      def assert_recognizes(expected_options, path, extras = {}, msg = nil)
         if path.is_a?(Hash) && path[:method].to_s == "all"
           [:get, :post, :put, :delete].each do |method|
             assert_recognizes(expected_options, path.merge(method: method), extras, msg)
@@ -75,19 +77,20 @@ module ActionDispatch
       #
       #   # Asserts that the generated route gives us our custom route
       #   assert_generates "changesets/12", { controller: 'scm', action: 'show_diff', revision: "12" }
-      def assert_generates(expected_path, options, defaults={}, extras={}, message=nil)
+      def assert_generates(expected_path, options, defaults = {}, extras = {}, message = nil)
         if expected_path =~ %r{://}
           fail_on(URI::InvalidURIError, message) do
             uri = URI.parse(expected_path)
             expected_path = uri.path.to_s.empty? ? "/" : uri.path
           end
         else
-          expected_path = "/#{expected_path}" unless expected_path.first == '/'
+          expected_path = "/#{expected_path}" unless expected_path.first == "/"
         end
         # Load routes.rb if it hasn't been loaded.
 
-        generated_path, extra_keys = @routes.generate_extras(options, defaults)
-        found_extras = options.reject { |k, _| ! extra_keys.include? k }
+        options = options.clone
+        generated_path, query_string_keys = @routes.generate_extras(options, defaults)
+        found_extras = options.reject { |k, _| ! query_string_keys.include? k }
 
         msg = message || sprintf("found extras <%s>, not <%s>", found_extras, extras)
         assert_equal(extras, found_extras, msg)
@@ -104,21 +107,21 @@ module ActionDispatch
       # The +extras+ hash allows you to specify options that would normally be provided as a query string to the action. The
       # +message+ parameter allows you to specify a custom error message to display upon failure.
       #
-      #  # Assert a basic route: a controller with the default action (index)
+      #  # Asserts a basic route: a controller with the default action (index)
       #  assert_routing '/home', controller: 'home', action: 'index'
       #
       #  # Test a route generated with a specific controller, action, and parameter (id)
       #  assert_routing '/entries/show/23', controller: 'entries', action: 'show', id: 23
       #
-      #  # Assert a basic route (controller + default action), with an error message if it fails
+      #  # Asserts a basic route (controller + default action), with an error message if it fails
       #  assert_routing '/store', { controller: 'store', action: 'index' }, {}, {}, 'Route for store index not generated properly'
       #
       #  # Tests a route, providing a defaults hash
       #  assert_routing 'controller/action/9', {id: "9", item: "square"}, {controller: "controller", action: "action"}, {}, {item: "square"}
       #
-      #  # Tests a route with a HTTP method
+      #  # Tests a route with an HTTP method
       #  assert_routing({ method: 'put', path: '/product/321' }, { controller: "product", action: "update", id: "321" })
-      def assert_routing(path, options, defaults={}, extras={}, message=nil)
+      def assert_routing(path, options, defaults = {}, extras = {}, message = nil)
         assert_recognizes(options, path, extras, message)
 
         controller, default_controller = options[:controller], defaults[:controller]
@@ -126,13 +129,12 @@ module ActionDispatch
           options[:controller] = "/#{controller}"
         end
 
-        generate_options = options.dup.delete_if{ |k, _| defaults.key?(k) }
+        generate_options = options.dup.delete_if { |k, _| defaults.key?(k) }
         assert_generates(path.is_a?(Hash) ? path[:path] : path, generate_options, defaults, extras, message)
       end
 
       # A helper to make it easier to test different route configurations.
-      # This method temporarily replaces @routes
-      # with a new RouteSet instance.
+      # This method temporarily replaces @routes with a new RouteSet instance.
       #
       # The new instance is yielded to the passed block. Typically the block
       # will create some routes using <tt>set.draw { match ... }</tt>:
@@ -150,9 +152,12 @@ module ActionDispatch
           old_controller, @controller = @controller, @controller.clone
           _routes = @routes
 
-          @controller.singleton_class.send(:include, _routes.url_helpers)
-          @controller.view_context_class = Class.new(@controller.view_context_class) do
-            include _routes.url_helpers
+          @controller.singleton_class.include(_routes.url_helpers)
+
+          if @controller.respond_to? :view_context_class
+            @controller.view_context_class = Class.new(@controller.view_context_class) do
+              include _routes.url_helpers
+            end
           end
         end
         yield @routes
@@ -182,8 +187,7 @@ module ActionDispatch
             method = :get
           end
 
-          # Assume given controller
-          request = ActionController::TestRequest.new
+          request = ActionController::TestRequest.create @controller.class
 
           if path =~ %r{://}
             fail_on(URI::InvalidURIError, msg) do
@@ -201,7 +205,7 @@ module ActionDispatch
           request.request_method = method if method
 
           params = fail_on(ActionController::RoutingError, msg) do
-            @routes.recognize_path(path, { :method => method, :extras => extras })
+            @routes.recognize_path(path, method: method, extras: extras)
           end
           request.path_parameters = params.with_indifferent_access