rspec-rails 1.3.2 → 6.1.2

data/lib/rspec/rails/matchers/have_http_status.rb

@@ -0,0 +1,385 @@
+# The following code inspired and modified from Rails' `assert_response`:
+#
+#   https://github.com/rails/rails/blob/main/actionpack/lib/action_dispatch/testing/assertions/response.rb#L22-L38
+#
+# Thank you to all the Rails devs who did the heavy lifting on this!
+
+module RSpec
+  module Rails
+    module Matchers
+      # Namespace for various implementations of `have_http_status`.
+      #
+      # @api private
+      module HaveHttpStatus
+        # Instantiates an instance of the proper matcher based on the provided
+        # `target`.
+        #
+        # @param target [Object] expected http status or code
+        # @return response matcher instance
+        def self.matcher_for_status(target)
+          if GenericStatus.valid_statuses.include?(target)
+            GenericStatus.new(target)
+          elsif Symbol === target
+            SymbolicStatus.new(target)
+          else
+            NumericCode.new(target)
+          end
+        end
+
+        # @api private
+        # Conversion function to coerce the provided object into an
+        # `ActionDispatch::TestResponse`.
+        #
+        # @param obj [Object] object to convert to a response
+        # @return [ActionDispatch::TestResponse]
+        def as_test_response(obj)
+          if ::ActionDispatch::Response === obj
+            ::ActionDispatch::TestResponse.from_response(obj)
+          elsif ::ActionDispatch::TestResponse === obj
+            obj
+          elsif obj.respond_to?(:status_code) && obj.respond_to?(:response_headers)
+            # Acts As Capybara Session
+            # Hack to support `Capybara::Session` without having to load
+            # Capybara or catch `NameError`s for the undefined constants
+            obj = ActionDispatch::Response.new.tap do |resp|
+              resp.status  = obj.status_code
+              resp.headers.clear
+              resp.headers.merge!(obj.response_headers)
+              resp.body    = obj.body
+              resp.request = ActionDispatch::Request.new({})
+            end
+            ::ActionDispatch::TestResponse.from_response(obj)
+          else
+            raise TypeError, "Invalid response type: #{obj}"
+          end
+        end
+        module_function :as_test_response
+
+        # @return [String, nil] a formatted failure message if
+        #   `@invalid_response` is present, `nil` otherwise
+        def invalid_response_type_message
+          return unless @invalid_response
+
+          "expected a response object, but an instance of " \
+          "#{@invalid_response.class} was received"
+        end
+
+        # @api private
+        # Provides an implementation for `have_http_status` matching against
+        # numeric http status codes.
+        #
+        # Not intended to be instantiated directly.
+        #
+        # @example
+        #   expect(response).to have_http_status(404)
+        #
+        # @see RSpec::Rails::Matchers#have_http_status
+        class NumericCode < RSpec::Rails::Matchers::BaseMatcher
+          include HaveHttpStatus
+
+          def initialize(code)
+            @expected = code.to_i
+            @actual = nil
+            @invalid_response = nil
+          end
+
+          # @param [Object] response object providing an http code to match
+          # @return [Boolean] `true` if the numeric code matched the `response` code
+          def matches?(response)
+            test_response = as_test_response(response)
+            @actual = test_response.response_code.to_i
+            expected == @actual
+          rescue TypeError => _ignored
+            @invalid_response = response
+            false
+          end
+
+          # @return [String]
+          def description
+            "respond with numeric status code #{expected}"
+          end
+
+          # @return [String] explaining why the match failed
+          def failure_message
+            invalid_response_type_message ||
+            "expected the response to have status code #{expected.inspect}" \
+              " but it was #{actual.inspect}"
+          end
+
+          # @return [String] explaining why the match failed
+          def failure_message_when_negated
+            invalid_response_type_message ||
+            "expected the response not to have status code " \
+            "#{expected.inspect} but it did"
+          end
+        end
+
+        # @api private
+        # Provides an implementation for `have_http_status` matching against
+        # Rack symbol http status codes.
+        #
+        # Not intended to be instantiated directly.
+        #
+        # @example
+        #   expect(response).to have_http_status(:created)
+        #
+        # @see RSpec::Rails::Matchers#have_http_status
+        # @see https://github.com/rack/rack/blob/master/lib/rack/utils.rb `Rack::Utils::SYMBOL_TO_STATUS_CODE`
+        class SymbolicStatus < RSpec::Rails::Matchers::BaseMatcher
+          include HaveHttpStatus
+
+          def initialize(status)
+            @expected_status = status
+            @actual = nil
+            @invalid_response = nil
+            set_expected_code!
+          end
+
+          # @param [Object] response object providing an http code to match
+          # @return [Boolean] `true` if Rack's associated numeric HTTP code matched
+          #   the `response` code
+          def matches?(response)
+            test_response = as_test_response(response)
+            @actual = test_response.response_code
+            expected == @actual
+          rescue TypeError => _ignored
+            @invalid_response = response
+            false
+          end
+
+          # @return [String]
+          def description
+            "respond with status code #{pp_expected}"
+          end
+
+          # @return [String] explaining why the match failed
+          def failure_message
+            invalid_response_type_message ||
+            "expected the response to have status code #{pp_expected} but it" \
+              " was #{pp_actual}"
+          end
+
+          # @return [String] explaining why the match failed
+          def failure_message_when_negated
+            invalid_response_type_message ||
+            "expected the response not to have status code #{pp_expected} " \
+              "but it did"
+          end
+
+          # The initialized expected status symbol
+          attr_reader :expected_status
+          private :expected_status
+
+        private
+
+          # @return [Symbol] representing the actual http numeric code
+          def actual_status
+            return unless actual
+
+            @actual_status ||= compute_status_from(actual)
+          end
+
+          # Reverse lookup of the Rack status code symbol based on the numeric
+          # http code
+          #
+          # @param code [Fixnum] http status code to look up
+          # @return [Symbol] representing the http numeric code
+          def compute_status_from(code)
+            status, _ = Rack::Utils::SYMBOL_TO_STATUS_CODE.find do |_, c|
+              c == code
+            end
+            status
+          end
+
+          # @return [String] pretty format the actual response status
+          def pp_actual
+            pp_status(actual_status, actual)
+          end
+
+          # @return [String] pretty format the expected status and associated code
+          def pp_expected
+            pp_status(expected_status, expected)
+          end
+
+          # @return [String] pretty format the actual response status
+          def pp_status(status, code)
+            if status
+              "#{status.inspect} (#{code})"
+            else
+              code.to_s
+            end
+          end
+
+          # Sets `expected` to the numeric http code based on the Rack
+          # `expected_status` status
+          #
+          # @see Rack::Utils::SYMBOL_TO_STATUS_CODE
+          # @raise [ArgumentError] if an associated code could not be found
+          def set_expected_code!
+            @expected ||=
+              Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(expected_status) do
+                raise ArgumentError,
+                      "Invalid HTTP status: #{expected_status.inspect}"
+              end
+          end
+        end
+
+        # @api private
+        # Provides an implementation for `have_http_status` matching against
+        # `ActionDispatch::TestResponse` http status category queries.
+        #
+        # Not intended to be instantiated directly.
+        #
+        # @example
+        #   expect(response).to have_http_status(:success)
+        #   expect(response).to have_http_status(:error)
+        #   expect(response).to have_http_status(:missing)
+        #   expect(response).to have_http_status(:redirect)
+        #
+        # @see RSpec::Rails::Matchers#have_http_status
+        # @see https://github.com/rails/rails/blob/6-0-stable/actionpack/lib/action_dispatch/testing/test_response.rb `ActionDispatch::TestResponse`
+        class GenericStatus < RSpec::Rails::Matchers::BaseMatcher
+          include HaveHttpStatus
+
+          # @return [Array<Symbol>] of status codes which represent a HTTP status
+          #   code "group"
+          # @see https://github.com/rails/rails/blob/main/actionpack/lib/action_dispatch/testing/test_response.rb `ActionDispatch::TestResponse`
+          def self.valid_statuses
+            [
+              :error, :success, :missing,
+              :server_error, :successful, :not_found,
+              :redirect
+            ]
+          end
+
+          def initialize(type)
+            unless self.class.valid_statuses.include?(type)
+              raise ArgumentError, "Invalid generic HTTP status: #{type.inspect}"
+            end
+
+            @expected = type
+            @actual = nil
+            @invalid_response = nil
+          end
+
+          # @return [Boolean] `true` if Rack's associated numeric HTTP code matched
+          #   the `response` code or the named response status
+          def matches?(response)
+            test_response = as_test_response(response)
+            @actual = test_response.response_code
+            check_expected_status(test_response, expected)
+          rescue TypeError => _ignored
+            @invalid_response = response
+            false
+          end
+
+          # @return [String]
+          def description
+            "respond with #{type_message}"
+          end
+
+          # @return [String] explaining why the match failed
+          def failure_message
+            invalid_response_type_message ||
+            "expected the response to have #{type_message} but it was #{actual}"
+          end
+
+          # @return [String] explaining why the match failed
+          def failure_message_when_negated
+            invalid_response_type_message ||
+            "expected the response not to have #{type_message} but it was #{actual}"
+          end
+
+        protected
+
+          RESPONSE_METHODS = {
+            success: 'successful',
+            error: 'server_error',
+            missing: 'not_found'
+          }.freeze
+
+          def check_expected_status(test_response, expected)
+            test_response.send(
+              "#{RESPONSE_METHODS.fetch(expected, expected)}?")
+          end
+
+        private
+
+          # @return [String] formatting the expected status and associated code(s)
+          def type_message
+            @type_message ||= (expected == :error ? "an error" : "a #{expected}") +
+              " status code (#{type_codes})"
+          end
+
+          # @return [String] formatting the associated code(s) for the various
+          #   status code "groups"
+          # @see https://github.com/rails/rails/blob/main/actionpack/lib/action_dispatch/testing/test_response.rb `ActionDispatch::TestResponse`
+          # @see https://github.com/rack/rack/blob/master/lib/rack/response.rb `Rack::Response`
+          def type_codes
+            # At the time of this commit the most recent version of
+            # `ActionDispatch::TestResponse` defines the following aliases:
+            #
+            #     alias_method :success?,  :successful?
+            #     alias_method :missing?,  :not_found?
+            #     alias_method :redirect?, :redirection?
+            #     alias_method :error?,    :server_error?
+            #
+            # It's parent `ActionDispatch::Response` includes
+            # `Rack::Response::Helpers` which defines the aliased methods as:
+            #
+            #     def successful?;   status >= 200 && status < 300; end
+            #     def redirection?;  status >= 300 && status < 400; end
+            #     def server_error?; status >= 500 && status < 600; end
+            #     def not_found?;    status == 404;                 end
+            #
+            # @see https://github.com/rails/rails/blob/ca200378/actionpack/lib/action_dispatch/testing/test_response.rb#L17-L27
+            # @see https://github.com/rails/rails/blob/ca200378/actionpack/lib/action_dispatch/http/response.rb#L74
+            # @see https://github.com/rack/rack/blob/ce4a3959/lib/rack/response.rb#L119-L122
+            @type_codes ||= case expected
+                            when :error, :server_error
+                              "5xx"
+                            when :success, :successful
+                              "2xx"
+                            when :missing, :not_found
+                              "404"
+                            when :redirect
+                              "3xx"
+                            end
+          end
+        end
+      end
+
+      # @api public
+      # Passes if `response` has a matching HTTP status code.
+      #
+      # The following symbolic status codes are allowed:
+      #
+      # - `Rack::Utils::SYMBOL_TO_STATUS_CODE`
+      # - One of the defined `ActionDispatch::TestResponse` aliases:
+      #   - `:error`
+      #   - `:missing`
+      #   - `:redirect`
+      #   - `:success`
+      #
+      # @example Accepts numeric and symbol statuses
+      #   expect(response).to have_http_status(404)
+      #   expect(response).to have_http_status(:created)
+      #   expect(response).to have_http_status(:success)
+      #   expect(response).to have_http_status(:error)
+      #   expect(response).to have_http_status(:missing)
+      #   expect(response).to have_http_status(:redirect)
+      #
+      # @example Works with standard `response` objects and Capybara's `page`
+      #   expect(response).to have_http_status(404)
+      #   expect(page).to     have_http_status(:created)
+      #
+      # @see https://github.com/rails/rails/blob/main/actionpack/lib/action_dispatch/testing/test_response.rb `ActionDispatch::TestResponse`
+      # @see https://github.com/rack/rack/blob/master/lib/rack/utils.rb `Rack::Utils::SYMBOL_TO_STATUS_CODE`
+      def have_http_status(target)
+        raise ArgumentError, "Invalid HTTP status: nil" unless target
+
+        HaveHttpStatus.matcher_for_status(target)
+      end
+    end
+  end
+end

data/lib/rspec/rails/matchers/have_rendered.rb

@@ -0,0 +1,64 @@
+module RSpec
+  module Rails
+    module Matchers
+      # Matcher for template rendering.
+      module RenderTemplate
+        # @private
+        class RenderTemplateMatcher < RSpec::Rails::Matchers::BaseMatcher
+          def initialize(scope, expected, message = nil)
+            @expected = Symbol === expected ? expected.to_s : expected
+            @message = message
+            @scope = scope
+            @redirect_is = nil
+          end
+
+          # @api private
+          def matches?(*)
+            match_check = match_unless_raises ActiveSupport::TestCase::Assertion do
+              @scope.assert_template expected, @message
+            end
+            check_redirect unless match_check
+            match_check
+          end
+
+          # Uses normalize_argument_to_redirection to find and format
+          # the redirect location. normalize_argument_to_redirection is private
+          # in ActionDispatch::Assertions::ResponseAssertions so we call it
+          # here using #send. This will keep the error message format consistent
+          # @api private
+          def check_redirect
+            response = @scope.response
+            return unless response.respond_to?(:redirect?) && response.redirect?
+
+            @redirect_is = @scope.send(:normalize_argument_to_redirection, response.location)
+          end
+
+          # @api private
+          def failure_message
+            if @redirect_is
+              rescued_exception.message[/(.*?)( but|$)/, 1] +
+                " but was a redirect to <#{@redirect_is}>"
+            else
+              rescued_exception.message
+            end
+          end
+
+          # @api private
+          def failure_message_when_negated
+            "expected not to render #{expected.inspect}, but did"
+          end
+        end
+
+        # Delegates to `assert_template`.
+        #
+        # @example
+        #     expect(response).to have_rendered("new")
+        def have_rendered(options, message = nil)
+          RenderTemplateMatcher.new(self, options, message)
+        end
+
+        alias_method :render_template, :have_rendered
+      end
+    end
+  end
+end

data/lib/rspec/rails/matchers/redirect_to.rb

@@ -0,0 +1,38 @@
+module RSpec
+  module Rails
+    module Matchers
+      # Matcher for redirects.
+      module RedirectTo
+        # @private
+        class RedirectTo < RSpec::Rails::Matchers::BaseMatcher
+          def initialize(scope, expected)
+            @expected = expected
+            @scope = scope
+          end
+
+          def matches?(_)
+            match_unless_raises ActiveSupport::TestCase::Assertion do
+              @scope.assert_redirected_to(@expected)
+            end
+          end
+
+          def failure_message
+            rescued_exception.message
+          end
+
+          def failure_message_when_negated
+            "expected not to redirect to #{@expected.inspect}, but did"
+          end
+        end
+
+        # Delegates to `assert_redirected_to`.
+        #
+        # @example
+        #     expect(response).to redirect_to(:action => "new")
+        def redirect_to(target)
+          RedirectTo.new(self, target)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/rails/matchers/relation_match_array.rb

@@ -0,0 +1,3 @@
+if defined?(ActiveRecord::Relation) && defined?(RSpec::Matchers::BuiltIn::OperatorMatcher) # RSpec 4 removed OperatorMatcher
+  RSpec::Matchers::BuiltIn::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::BuiltIn::ContainExactly)
+end

data/lib/rspec/rails/matchers/routing_matchers.rb

@@ -0,0 +1,125 @@
+module RSpec
+  module Rails
+    module Matchers
+      # Matchers to help with specs for routing code.
+      module RoutingMatchers
+        extend RSpec::Matchers::DSL
+
+        # @private
+        class RouteToMatcher < RSpec::Rails::Matchers::BaseMatcher
+          def initialize(scope, *expected)
+            @scope = scope
+            @expected = expected[1] || {}
+            if Hash === expected[0]
+              @expected.merge!(expected[0])
+            else
+              controller, action = expected[0].split('#')
+              @expected.merge!(controller: controller, action: action)
+            end
+          end
+
+          def matches?(verb_to_path_map)
+            @actual = verb_to_path_map
+            # assert_recognizes does not consider ActionController::RoutingError an
+            # assertion failure, so we have to capture that and Assertion here.
+            match_unless_raises ActiveSupport::TestCase::Assertion, ActionController::RoutingError do
+              path, query = *verb_to_path_map.values.first.split('?')
+              @scope.assert_recognizes(
+                @expected,
+                { method: verb_to_path_map.keys.first, path: path },
+                Rack::Utils.parse_nested_query(query)
+              )
+            end
+          end
+
+          def failure_message
+            rescued_exception.message
+          end
+
+          def failure_message_when_negated
+            "expected #{@actual.inspect} not to route to #{@expected.inspect}"
+          end
+
+          def description
+            "route #{@actual.inspect} to #{@expected.inspect}"
+          end
+        end
+
+        # Delegates to `assert_recognizes`. Supports short-hand controller/action
+        # declarations (e.g. `"controller#action"`).
+        #
+        # @example
+        #
+        #     expect(get: "/things/special").to route_to(
+        #       controller: "things",
+        #       action:     "special"
+        #     )
+        #
+        #     expect(get: "/things/special").to route_to("things#special")
+        #
+        # @see https://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_recognizes
+        def route_to(*expected)
+          RouteToMatcher.new(self, *expected)
+        end
+
+        # @private
+        class BeRoutableMatcher < RSpec::Rails::Matchers::BaseMatcher
+          def initialize(scope)
+            @scope = scope
+          end
+
+          def matches?(path)
+            @actual = path
+            match_unless_raises ActionController::RoutingError do
+              @routing_options = @scope.routes.recognize_path(
+                path.values.first, method: path.keys.first
+              )
+            end
+          end
+
+          def failure_message
+            "expected #{@actual.inspect} to be routable"
+          end
+
+          def failure_message_when_negated
+            "expected #{@actual.inspect} not to be routable, but it routes to #{@routing_options.inspect}"
+          end
+
+          def description
+            "be routable"
+          end
+        end
+
+        # Passes if the route expression is recognized by the Rails router based on
+        # the declarations in `config/routes.rb`. Delegates to
+        # `RouteSet#recognize_path`.
+        #
+        # @example You can use route helpers provided by rspec-rails.
+        #     expect(get:  "/a/path").to be_routable
+        #     expect(post: "/another/path").to be_routable
+        #     expect(put:  "/yet/another/path").to be_routable
+        def be_routable
+          BeRoutableMatcher.new(self)
+        end
+
+        # Helpers for matching different route types.
+        module RouteHelpers
+          # @!method get
+          # @!method post
+          # @!method put
+          # @!method patch
+          # @!method delete
+          # @!method options
+          # @!method head
+          #
+          # Shorthand method for matching this type of route.
+          %w[get post put patch delete options head].each do |method|
+            define_method method do |path|
+              { method.to_sym => path }
+            end
+          end
+        end
+      end
+    end
+  end
+end