rspec-rails 3.0.2 → 3.1.0

data/lib/rspec/rails/extensions/active_record/proxy.rb

@@ -14,4 +14,3 @@ RSpec.configure do |rspec|
     end
   end
 end
-

data/lib/rspec/rails/feature_check.rb

@@ -0,0 +1,35 @@
+# @api private
+module RSpec
+  module Rails
+    # Disable some cops until https://github.com/bbatsov/rubocop/issues/1310
+    # rubocop:disable Style/IndentationConsistency
+    module FeatureCheck
+    # rubocop:disable Style/IndentationWidth
+    module_function
+      # rubocop:enable Style/IndentationWidth
+
+      def can_check_pending_migrations?
+        has_active_record_migration? &&
+          ::ActiveRecord::Migration.respond_to?(:check_pending!)
+      end
+
+      def can_maintain_test_schema?
+        has_active_record_migration? &&
+          ::ActiveRecord::Migration.respond_to?(:maintain_test_schema!)
+      end
+
+      def has_active_job?
+        defined?(::ActiveJob)
+      end
+
+      def has_active_record?
+        defined?(::ActiveRecord)
+      end
+
+      def has_active_record_migration?
+        has_active_record? && defined?(::ActiveRecord::Migration)
+      end
+    end
+    # rubocop:enable Style/IndentationConsistency
+  end
+end

data/lib/rspec/rails/fixture_support.rb

@@ -10,7 +10,7 @@ module RSpec
         include ActiveRecord::TestFixtures
 
         included do
-          # TODO (DC 2011-06-25) this is necessary because fixture_file_upload
+          # TODO: (DC 2011-06-25) this is necessary because fixture_file_upload
           # accesses fixture_path directly on ActiveSupport::TestCase. This is
           # fixed in rails by https://github.com/rails/rails/pull/1861, which
           # should be part of the 3.1 release, at which point we can include

data/lib/rspec/rails/matchers.rb

@@ -1,8 +1,11 @@
 require 'rspec/core/warnings'
 require 'rspec/expectations'
 
-module RSpec::Rails
-  module Matchers
+module RSpec
+  module Rails
+    # Container module for Rails specific matchers.
+    module Matchers
+    end
   end
 end
 

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

@@ -1,77 +1,81 @@
-module RSpec::Rails::Matchers
-  # @api private
-  #
-  # Matcher class for `be_a_new`. Should not be instantiated directly.
-  #
-  # @see RSpec::Rails::Matchers#be_a_new
-  class BeANew < RSpec::Matchers::BuiltIn::BaseMatcher
-    # @private
-    def initialize(expected)
-      @expected = expected
-    end
-
-    # @private
-    def matches?(actual)
-      @actual = actual
-      actual.is_a?(expected) && actual.new_record? && attributes_match?(actual)
-    end
+module RSpec
+  module Rails
+    module Matchers
+      # @api private
+      #
+      # Matcher class for `be_a_new`. Should not be instantiated directly.
+      #
+      # @see RSpec::Rails::Matchers#be_a_new
+      class BeANew < RSpec::Matchers::BuiltIn::BaseMatcher
+        # @private
+        def initialize(expected)
+          @expected = expected
+        end
 
-    # @api public
-    # @see RSpec::Rails::Matchers#be_a_new
-    def with(expected_attributes)
-      attributes.merge!(expected_attributes)
-      self
-    end
+        # @private
+        def matches?(actual)
+          @actual = actual
+          actual.is_a?(expected) && actual.new_record? && attributes_match?(actual)
+        end
 
-    # @private
-    def failure_message
-      [].tap do |message|
-        unless actual.is_a?(expected) && actual.new_record?
-          message << "expected #{actual.inspect} to be a new #{expected.inspect}"
+        # @api public
+        # @see RSpec::Rails::Matchers#be_a_new
+        def with(expected_attributes)
+          attributes.merge!(expected_attributes)
+          self
         end
-        unless attributes_match?(actual)
-          if unmatched_attributes.size > 1
-            message << "attributes #{unmatched_attributes.inspect} were not set on #{actual.inspect}"
-          else
-            message << "attribute #{unmatched_attributes.inspect} was not set on #{actual.inspect}"
-          end
+
+        # @private
+        def failure_message
+          [].tap do |message|
+            unless actual.is_a?(expected) && actual.new_record?
+              message << "expected #{actual.inspect} to be a new #{expected.inspect}"
+            end
+            unless attributes_match?(actual)
+              if unmatched_attributes.size > 1
+                message << "attributes #{unmatched_attributes.inspect} were not set on #{actual.inspect}"
+              else
+                message << "attribute #{unmatched_attributes.inspect} was not set on #{actual.inspect}"
+              end
+            end
+          end.join(' and ')
         end
-      end.join(' and ')
-    end
 
-    private
+      private
 
-    def attributes
-      @attributes ||= {}
-    end
+        def attributes
+          @attributes ||= {}
+        end
 
-    def attributes_match?(actual)
-      attributes.stringify_keys.all? do |key, value|
-        actual.attributes[key].eql?(value)
+        def attributes_match?(actual)
+          attributes.stringify_keys.all? do |key, value|
+            actual.attributes[key].eql?(value)
+          end
+        end
+
+        def unmatched_attributes
+          attributes.stringify_keys.reject do |key, value|
+            actual.attributes[key].eql?(value)
+          end
+        end
       end
-    end
 
-    def unmatched_attributes
-      attributes.stringify_keys.reject do |key, value|
-        actual.attributes[key].eql?(value)
+      # Passes if actual is an instance of `model_class` and returns `false` for
+      # `persisted?`. Typically used to specify instance variables assigned to
+      # views by controller actions
+      #
+      # Use the `with` method to specify the specific attributes to match on the
+      # new record.
+      #
+      # @example
+      #     get :new
+      #     assigns(:thing).should be_a_new(Thing)
+      #
+      #     post :create, :thing => { :name => "Illegal Value" }
+      #     assigns(:thing).should be_a_new(Thing).with(:name => nil)
+      def be_a_new(model_class)
+        BeANew.new(model_class)
       end
     end
   end
-
-  # Passes if actual is an instance of `model_class` and returns `false` for
-  # `persisted?`. Typically used to specify instance variables assigned to
-  # views by controller actions
-  #
-  # Use the `with` method to specify the specific attributes to match on the
-  # new record.
-  #
-  # @example
-  #     get :new
-  #     assigns(:thing).should be_a_new(Thing)
-  #
-  #     post :create, :thing => { :name => "Illegal Value" }
-  #     assigns(:thing).should be_a_new(Thing).with(:name => nil)
-  def be_a_new(model_class)
-    BeANew.new(model_class)
-  end
 end

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

@@ -1,25 +1,29 @@
-module RSpec::Rails::Matchers
-  # @private
-  class BeANewRecord < RSpec::Matchers::BuiltIn::BaseMatcher
-    def matches?(actual)
-      !actual.persisted?
-    end
+module RSpec
+  module Rails
+    module Matchers
+      # @private
+      class BeANewRecord < RSpec::Matchers::BuiltIn::BaseMatcher
+        def matches?(actual)
+          !actual.persisted?
+        end
 
-    def failure_message
-      "expected #{actual.inspect} to be a new record, but was persisted"
-    end
+        def failure_message
+          "expected #{actual.inspect} to be a new record, but was persisted"
+        end
 
-    def failure_message_when_negated
-      "expected #{actual.inspect} to be persisted, but was a new record"
-    end
-  end
+        def failure_message_when_negated
+          "expected #{actual.inspect} to be persisted, but was a new record"
+        end
+      end
 
-  # Passes if actual returns `false` for `persisted?`.
-  #
-  # @example
-  #     get :new
-  #     expect(assigns(:thing)).to be_new_record
-  def be_new_record
-    BeANewRecord.new
+      # Passes if actual returns `false` for `persisted?`.
+      #
+      # @example
+      #     get :new
+      #     expect(assigns(:thing)).to be_new_record
+      def be_new_record
+        BeANewRecord.new
+      end
+    end
   end
 end

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

@@ -1,44 +1,48 @@
-module RSpec::Rails::Matchers
-  # @private
-  class BeValid < RSpec::Matchers::BuiltIn::Be
-    def initialize(*args)
-      @args = args
-    end
+module RSpec
+  module Rails
+    module Matchers
+      # @private
+      class BeValid < RSpec::Matchers::BuiltIn::Be
+        def initialize(*args)
+          @args = args
+        end
 
-    def matches?(actual)
-      @actual = actual
-      actual.valid?(*@args)
-    end
+        def matches?(actual)
+          @actual = actual
+          actual.valid?(*@args)
+        end
+
+        def failure_message
+          message = "expected #{actual.inspect} to be valid"
+
+          if actual.respond_to?(:errors)
+            errors = if actual.errors.respond_to?(:full_messages)
+                       actual.errors.full_messages
+                     else
+                       actual.errors
+                     end
 
-    def failure_message
-      message = "expected #{actual.inspect} to be valid"
+            message << ", but got errors: #{errors.map(&:to_s).join(', ')}"
+          end
 
-      if actual.respond_to?(:errors)
-        errors = if actual.errors.respond_to?(:full_messages)
-          actual.errors.full_messages
-        else
-          actual.errors
+          message
         end
 
-        message << ", but got errors: #{errors.map(&:to_s).join(', ')}"
+        def failure_message_when_negated
+          "expected #{actual.inspect} not to be valid"
+        end
       end
 
-      message
-    end
-
-    def failure_message_when_negated
-      "expected #{actual.inspect} not to be valid"
+      # Passes if the given model instance's `valid?` method is true, meaning
+      # all of the `ActiveModel::Validations` passed and no errors exist. If a
+      # message is not given, a default message is shown listing each error.
+      #
+      # @example
+      #     thing = Thing.new
+      #     expect(thing).to be_valid
+      def be_valid(*args)
+        BeValid.new(*args)
+      end
     end
   end
-
-  # Passes if the given model instance's `valid?` method is true, meaning all
-  # of the `ActiveModel::Validations` passed and no errors exist. If a message
-  # is not given, a default message is shown listing each error.
-  #
-  # @example
-  #     thing = Thing.new
-  #     expect(thing).to be_valid
-  def be_valid(*args)
-    BeValid.new(*args)
-  end
 end

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

@@ -4,352 +4,358 @@
 #
 # Thank you to all the Rails devs who did the heavy lifting on this!
 
-module RSpec::Rails::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
-        ::ActionDispatch::TestResponse.new.tap{ |resp|
-          resp.status  = obj.status_code
-          resp.headers = obj.response_headers
-          resp.body    = obj.body
-        }
-      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
-      if @invalid_response
-        "expected a response object, but an instance of " +
-        "#{@invalid_response.class} was received"
-      end
-    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::Matchers::BuiltIn::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
-        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::Matchers::BuiltIn::BaseMatcher
-      include HaveHttpStatus
-
-      def initialize(status)
-        @expected_status = status
-        @actual = nil
-        @invalid_response = nil
-        unless set_expected_code!
-          raise ArgumentError, "Invalid HTTP status: #{status.inspect}"
+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
-      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
-        if actual
-          @actual_status ||= compute_status_from(actual)
+        # @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
+            ::ActionDispatch::TestResponse.new.tap do |resp|
+              resp.status  = obj.status_code
+              resp.headers = obj.response_headers
+              resp.body    = obj.body
+            end
+          else
+            raise TypeError, "Invalid response type: #{obj}"
+          end
         end
-      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{ |_, c| c == code }
-        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
+        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
-      end
-
-      # Sets `expected` to the numeric http code based on the Rack
-      # `expected_status` status
-      #
-      # @see Rack::Utils::SYMBOL_TO_STATUS_CODE
-      # @return [nil] if an associated code could not be found
-      def set_expected_code!
-        @expected ||= Rack::Utils::SYMBOL_TO_STATUS_CODE[expected_status]
-      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 ActionDispatch::TestResponse
-    class GenericStatus < RSpec::Matchers::BuiltIn::BaseMatcher
-      include HaveHttpStatus
-
-      # @return [Array<Symbol>] of status codes which represent a HTTP status
-      #   code "group"
-      # @see https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/testing/test_response.rb `ActionDispatch::TestResponse`
-      def self.valid_statuses
-        [:error, :success, :missing, :redirect]
-      end
-
-      def initialize(type)
-        unless self.class.valid_statuses.include?(type)
-          raise ArgumentError, "Invalid generic HTTP status: #{type.inspect}"
+        # @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::Matchers::BuiltIn::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
+            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
-        @expected = type
-        @actual = nil
-        @invalid_response = nil
-      end
-
-      # @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
-        test_response.send("#{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
-
-    private
 
-      # @return [String] formating 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/master/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:
+        # @api private
+        # Provides an implementation for `have_http_status` matching against
+        # Rack symbol http status codes.
         #
-        #     alias_method :success?,  :successful?
-        #     alias_method :missing?,  :not_found?
-        #     alias_method :redirect?, :redirection?
-        #     alias_method :error?,    :server_error?
+        # Not intended to be instantiated directly.
         #
-        # It's parent `ActionDispatch::Response` includes
-        # `Rack::Response::Helpers` which defines the aliased methods as:
+        # @example
+        #   expect(response).to have_http_status(:created)
         #
-        #     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 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::Matchers::BuiltIn::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.
         #
-        # @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
-                          "5xx"
-                        when :success
-                          "2xx"
-                        when :missing
-                          "404"
-                        when :redirect
-                          "3xx"
-                        end
+        # @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 ActionDispatch::TestResponse
+        class GenericStatus < RSpec::Matchers::BuiltIn::BaseMatcher
+          include HaveHttpStatus
+
+          # @return [Array<Symbol>] of status codes which represent a HTTP status
+          #   code "group"
+          # @see https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/testing/test_response.rb `ActionDispatch::TestResponse`
+          def self.valid_statuses
+            [:error, :success, :missing, :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
+          def matches?(response)
+            test_response = as_test_response(response)
+            @actual = test_response.response_code
+            test_response.send("#{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
+
+        private
+
+          # @return [String] formating 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/master/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
+                              "5xx"
+                            when :success
+                              "2xx"
+                            when :missing
+                              "404"
+                            when :redirect
+                              "3xx"
+                            end
+          end
+        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/master/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)
+      # @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/master/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