shoulda-matchers 3.0.0.rc1 → 3.0.0

data/spec/support/acceptance/matchers/have_output.rb

@@ -18,7 +18,7 @@ module AcceptanceTests
         "Expected command to have output, but did not.\n\n" +
           "Command: #{runner.formatted_command}\n\n" +
           "Expected output:\n" +
-          output + "\n\n" +
+          output.inspect + "\n\n" +
           "Actual output:\n" +
           runner.output
       end

data/spec/support/acceptance/matchers/indicate_number_of_tests_was_run_matcher.rb

@@ -40,7 +40,7 @@ module AcceptanceTests
       private
 
       def expected_output
-        /#{number} (tests|runs), #{number} assertions, 0 failures, 0 errors(, 0 skips)?/
+        /#{number} (?:tests?|runs?|examples?)(?:, #{number} assertions)?, 0 failures(?:, 0 errors(?:, 0 skips)?)?/
       end
 
       def actual_output

data/spec/support/tests/command_runner.rb

@@ -117,7 +117,11 @@ Output:
     end
 
     def has_output?(expected_output)
-      output.include?(expected_output)
+      if expected_output.is_a?(Regexp)
+        output =~ expected_output
+      else
+        output.include?(expected_output)
+      end
     end
 
     protected

data/spec/support/unit/helpers/active_record_versions.rb

@@ -9,10 +9,6 @@ module UnitTests
       Tests::Version.new(ActiveRecord::VERSION::STRING)
     end
 
-    def active_record_can_raise_range_error?
-      active_record_version >= 4.2
-    end
-
     def active_record_supports_enum?
       defined?(::ActiveRecord::Enum)
     end

data/spec/support/unit/shared_examples/set_session_or_flash.rb

@@ -56,9 +56,14 @@ shared_examples_for 'set session or flash matcher' do
 
     context 'in the positive' do
       context 'if the given key is present in the store' do
-        it 'accepts' do
-          controller = controller_with_store('the key' => 'any value')
-          expect(controller).to set_store['the key']
+        it 'accepts the param as a string' do
+          controller = controller_with_store('the_key' => 'any value')
+          expect(controller).to set_store['the_key']
+        end
+
+        it 'accepts the param as a symbol' do
+          controller = controller_with_store('the_key' => 'any value')
+          expect(controller).to set_store[:the_key]
         end
       end
 

data/spec/unit/shoulda/matchers/action_controller/permit_matcher_spec.rb

@@ -7,7 +7,7 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
         params_with_conditional_require(ctrl.params).permit(:name, :age)
       end
 
-      expect(controller).to permit_with_conditional_params(
+      expect(controller).to permit_with_conditional_slice_of_params(
         permit(:name).for(:create)
       )
     end
@@ -17,7 +17,7 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
         params_with_conditional_require(ctrl.params).permit(:name, :age)
       end
 
-      expect(controller).to permit_with_conditional_params(
+      expect(controller).to permit_with_conditional_slice_of_params(
         permit(:name, :age).for(:create)
       )
     end
@@ -27,7 +27,7 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
         params_with_conditional_require(ctrl.params).permit(:name)
       end
 
-      expect(controller).not_to permit_with_conditional_params(
+      expect(controller).not_to permit_with_conditional_slice_of_params(
         permit(:name, :admin).for(:create)
       )
     end
@@ -35,22 +35,17 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
     it 'rejects when #permit has not been called' do
       define_controller_with_strong_parameters(action: :create)
 
-      expect(controller).not_to permit_with_conditional_params(
+      expect(controller).not_to permit_with_conditional_slice_of_params(
         permit(:name).for(:create)
       )
     end
 
-    it 'tracks multiple calls to #permit' do
+    it 'tracks multiple calls to #permit for different subparameters' do
       sets_of_attributes = [
         [:eta, :diner_id],
         [:phone_number, :address_1, :address_2, :city, :state, :zip]
       ]
 
-      params = {
-        order: { some: 'value' },
-        diner: { some: 'value' }
-      }
-
       define_controller_with_strong_parameters(action: :create) do |ctrl|
         params_with_conditional_require(ctrl.params, :order).
           permit(sets_of_attributes[0])
@@ -59,14 +54,16 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
           permit(sets_of_attributes[1])
       end
 
-      expect(controller).to permit_with_conditional_params(
+      expect(controller).to permit_with_conditional_slice_of_params(
         permit(*sets_of_attributes[0]).for(:create),
-        params
+        all_params: [:order, :diner],
+        selected_param: :order
       )
 
-      expect(controller).to permit_with_conditional_params(
+      expect(controller).to permit_with_conditional_slice_of_params(
         permit(*sets_of_attributes[1]).for(:create),
-        params
+        all_params: [:order, :diner],
+        selected_param: :diner
       )
     end
   end
@@ -91,7 +88,7 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
 
   context 'when operating on the entire params hash' do
     include_context 'basic tests' do
-      def permit_with_conditional_params(permit, _params = {})
+      def permit_with_conditional_slice_of_params(permit, options = {})
         permit
       end
 
@@ -103,9 +100,16 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
 
   context 'when operating on a slice of the params hash' do
     include_context 'basic tests' do
-      def permit_with_conditional_params(permit, params = nil)
-        params ||= { user: { some: 'value' } }
-        permit.add_params(params)
+      def permit_with_conditional_slice_of_params(
+        permit,
+        all_params: [:user],
+        selected_param: :user
+      )
+        params = all_params.reduce({}) do |hash, param|
+          hash.merge(param => { any: 'value' })
+        end
+
+        permit.add_params(params).on(selected_param)
       end
 
       def params_with_conditional_require(params, *filters)
@@ -127,6 +131,28 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
         for(:create, params: { order: { some: 'value' } }).
         on(:something_else)
     end
+
+    it 'tracks multiple calls to #permit for the same subparameter' do
+      define_controller_with_strong_parameters(action: :create) do
+        params.require(:foo).permit(:bar)
+        params.require(:foo).permit(:baz)
+      end
+
+      params = {
+        foo: {
+          bar: 'some value',
+          baz: 'some value'
+        }
+      }
+      expect(controller).
+        to permit(:bar).
+        on(:foo).
+        for(:create, params: params)
+      expect(controller).
+        to permit(:baz).
+        on(:foo).
+        for(:create, params: params)
+    end
   end
 
   it 'can be used more than once in the same test' do
@@ -138,7 +164,7 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
     expect(controller).not_to permit(:admin).for(:create)
   end
 
-  it 'allows extra parameters to be passed to the action if it requires them' do
+  it 'allows extra parameters to be provided if the route requires them' do
     options = {
       controller_name: 'Posts',
       action: :show,
@@ -259,7 +285,7 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
 
       matcher = described_class.new([:name, :age, :height]).for(:create)
       expect(matcher.description).to eq(
-        '(on POST #create) restrict parameters to :name, :age, and :height'
+        '(for POST #create) restrict parameters to :name, :age, and :height'
       )
     end
 
@@ -275,50 +301,183 @@ describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller d
           new([:name]).
           for(:some_action, verb: :put)
         expect(matcher.description).to eq(
-          '(on PUT #some_action) restrict parameters to :name'
+          '(for PUT #some_action) restrict parameters to :name'
         )
       end
     end
   end
 
   describe 'positive failure message' do
-    it 'includes all missing attributes' do
-      define_controller_with_strong_parameters(action: :create) do
-        params.permit(:name, :age)
+    context 'when no parameters were permitted' do
+      it 'returns the correct message' do
+        define_controller_with_strong_parameters(action: :create)
+
+        assertion = lambda do
+          expect(@controller).
+            to permit(:name, :age, :city, :country).
+            for(:create)
+        end
+
+        message =
+          'Expected POST #create to restrict parameters to ' +
+          ":name, :age, :city, and :country,\n" +
+          'but it did not restrict any parameters.'
+
+        expect(&assertion).to fail_with_message(message)
       end
+    end
 
-      assertion = lambda do
-        expect(@controller).
-          to permit(:name, :age, :city, :country).
-          for(:create)
+    context 'when some, but not all, parameters were permitted' do
+      it 'returns the correct message, including missing attributes' do
+        define_controller_with_strong_parameters(action: :create) do
+          params.permit(:name, :age)
+        end
+
+        assertion = lambda do
+          expect(@controller).
+            to permit(:name, :age, :city, :country).
+            for(:create)
+        end
+
+        message =
+          'Expected POST #create to restrict parameters to ' +
+          ":name, :age, :city, and :country,\n" +
+          'but the restricted parameters were :name and :age instead.'
+
+        expect(&assertion).to fail_with_message(message)
       end
+    end
 
-      message =
-        "Expected POST #create to restrict parameters to " +
-        ":name, :age, :city, and :country,\n" +
-        "but the restricted parameters were :name and :age instead."
+    context 'qualified with #on' do
+      context 'when the subparameter was never required' do
+        it 'returns the correct message' do
+          define_controller_with_strong_parameters(action: :create) do
+            params.permit(:name, :age)
+          end
 
-      expect(&assertion).to fail_with_message(message)
+          assertion = lambda do
+            expect(@controller).
+              to permit(:name, :age, :city, :country).
+              for(:create).
+              on(:person)
+          end
+
+          message =
+            'Expected POST #create to restrict parameters on :person to ' +
+            ":name, :age, :city, and :country,\n" +
+            'but it did not restrict any parameters.'
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when the subparameter was required' do
+        context 'but no parameters were permitted' do
+          it 'returns the correct message' do
+            define_controller_with_strong_parameters(action: :create) do
+              params.require(:person)
+            end
+
+            assertion = lambda do
+              params = {
+                person: {
+                  name: 'some name',
+                  age: 'some age'
+                }
+              }
+              expect(@controller).
+                to permit(:name, :age, :city, :country).
+                for(:create, params: params).
+                on(:person)
+            end
+
+            message =
+              'Expected POST #create to restrict parameters on :person to ' +
+              ":name, :age, :city, and :country,\n" +
+              'but it did not restrict any parameters.'
+
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+
+        context 'but some, but not all, parameters were permitted' do
+          it 'returns the correct message' do
+            define_controller_with_strong_parameters(action: :create) do
+              params.require(:person).permit(:name, :age)
+            end
+
+            assertion = lambda do
+              params = {
+                person: {
+                  name: 'some name',
+                  age: 'some age'
+                }
+              }
+              expect(@controller).
+                to permit(:name, :age, :city, :country).
+                for(:create, params: params).
+                on(:person)
+            end
+
+            message =
+              'Expected POST #create to restrict parameters on :person to ' +
+              ":name, :age, :city, and :country,\n" +
+              'but the restricted parameters were :name and :age instead.'
+
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+      end
     end
   end
 
   describe 'negative failure message' do
-    it 'includes all attributes that should not have been permitted but were' do
+    it 'returns the correct message' do
       define_controller_with_strong_parameters(action: :create) do
-        params.permit(:name, :age)
+        params.permit(:name, :age, :city, :country)
       end
 
       assertion = lambda do
-        expect(controller).not_to permit(:name, :age).for(:create)
+        expect(@controller).
+          not_to permit(:name, :age, :city, :country).
+          for(:create)
       end
 
       message =
-        "Expected POST #create not to restrict parameters to " +
-        ":name and :age,\n" +
-        "but it did."
+        'Expected POST #create not to restrict parameters to ' +
+        ":name, :age, :city, and :country,\n" +
+        'but it did.'
 
       expect(&assertion).to fail_with_message(message)
     end
+
+    context 'qualified with #on' do
+      it 'returns the correct message' do
+        define_controller_with_strong_parameters(action: :create) do
+          params.require(:person).permit(:name, :age)
+        end
+
+        assertion = lambda do
+          params = {
+            person: {
+              name: 'some name',
+              age: 'some age'
+            }
+          }
+          expect(@controller).
+            not_to permit(:name, :age).
+            for(:create, params: params).
+            on(:person)
+        end
+
+        message =
+          'Expected POST #create not to restrict parameters on :person to ' +
+          ":name and :age,\n" +
+          'but it did.'
+
+        expect(&assertion).to fail_with_message(message)
+      end
+    end
   end
 
   describe '#for' do

data/spec/unit/shoulda/matchers/action_controller/route_matcher_spec.rb

@@ -1,163 +1,330 @@
 require 'unit_spec_helper'
 
 describe 'Shoulda::Matchers::ActionController::RouteMatcher', type: :controller do
-  shared_examples_for 'a controller with a defined route' do
-    context 'when controller and action are specified as explicit options' do
+  shared_examples_for 'tests involving expected route parts' do |args|
+    include_controller_in_expected_route_options =
+      args.fetch(:include_controller_in_expected_route_options)
+
+    context 'when all parts of the expected route match an existing route' do
       it 'accepts' do
-        expect(controller_with_defined_routes).
-          to route(:get, "/#{controller_path}").
-          to(action: 'index')
+        define_route :get, '/', action: 'index'
+
+        assert_accepts add_target_to(
+          route(:get, '/'),
+          build_expected_route_options(
+            include_controller_in_expected_route_options,
+            action: 'index'
+          )
+        )
       end
 
-      it 'accepts a symbol controller' do
-        expect(controller_with_defined_routes).
-          to route(:get, "/#{controller_path}").
-          to(controller: controller_path.to_sym, action: 'index')
+      if include_controller_in_expected_route_options
+        context 'and the expected controller is specified as a symbol' do
+          it 'accepts' do
+            define_route :get, '/', action: 'index'
+
+            assert_accepts add_target_to(
+              route(:get, '/'),
+              build_expected_route_options(
+                include_controller_in_expected_route_options,
+                action: 'index'
+              )
+            )
+          end
+        end
       end
 
-      it 'accepts a symbol action' do
-        expect(controller_with_defined_routes).
-          to route(:get, "/#{controller_path}").
-          to(action: :index)
+      context 'and the expected action is specified as a symbol' do
+        it 'accepts' do
+          define_route :get, '/', action: 'index'
+
+          assert_accepts add_target_to(
+            route(:get, '/'),
+            build_expected_route_options(
+              include_controller_in_expected_route_options,
+              action: :index
+            )
+          )
+        end
       end
+    end
 
-      it 'rejects an undefined route' do
-        expect(controller_with_defined_routes).
-          not_to route(:get, '/non_existent_route').
-          to(action: 'non_existent')
+    context 'when no parts of the expected route match an existing route' do
+      it 'rejects' do
+        assert_rejects add_target_to(
+          route(:get, '/non_existent_route'),
+          controller: 'no_controller',
+          action: 'no_action'
+        )
       end
+    end
 
-      it 'rejects a route for another controller' do
-        define_controller_with_defined_routes
-        other_controller = define_controller('Other').new
-        expect(other_controller).
-          not_to route(:get, "/#{controller_path}").
-          to(action: 'index')
+    context 'when all parts of the expected route but the method match an existing route' do
+      it 'rejects' do
+        define_route :post, '/', action: 'index'
+
+        assert_rejects add_target_to(
+          route(:get, '/'),
+          build_expected_route_options(
+            include_controller_in_expected_route_options,
+            action: 'index'
+          )
+        )
       end
+    end
 
-      context 'when route has parameters' do
-        it 'accepts a non-string parameter' do
-          expect(controller_with_defined_routes).
-            to route(:get, "/#{controller_path}/1").
-            to(action: 'show', id: 1)
-        end
+    context 'when all parts of the expected route but the path match an existing route' do
+      it 'rejects' do
+        define_route :get, '/', action: 'index'
+
+        assert_rejects add_target_to(
+          route(:get, '/different_path'),
+          build_expected_route_options(
+            include_controller_in_expected_route_options,
+            action: 'index'
+          )
+        )
+      end
+    end
 
-        it 'rejects a route for different parameters' do
-          expect(controller_with_defined_routes).
-            not_to route(:get, "/#{controller_path}/1").
-            to(action: 'show', some: 'other', params: 'here')
+    if include_controller_in_expected_route_options
+      context 'when all parts of the expected route but the controller match an existing route' do
+        it 'rejects' do
+          define_route :get, '/', controller: 'another_controller', action: 'index'
+
+          assert_rejects add_target_to(
+            route(:get, '/'),
+            build_expected_route_options(
+              include_controller_in_expected_route_options,
+              action: 'index'
+            )
+          )
         end
       end
+    end
 
-      context 'when route has a default format' do
+    context 'when all parts of the expected route but the action match an existing route' do
+      it 'rejects' do
+        define_route :get, '/', action: 'index'
+
+        assert_rejects add_target_to(
+          route(:get, '/'),
+          build_expected_route_options(
+            include_controller_in_expected_route_options,
+            action: 'another_action'
+          )
+        )
+      end
+    end
+  end
+
+  shared_examples_for 'tests involving params' do
+    context 'when the actual route has a param' do
+      context 'and the expected params include that param' do
         it 'accepts' do
-          expect(controller_with_defined_routes).
-            to route(:post, "/#{controller_path}").
-            to(action: 'create', format: 'json')
+          define_route :get, "/#{controller_name}/:id", action: 'show'
+
+          assert_accepts add_target_to(
+            route(:get, "/#{controller_name}/1"),
+            controller: controller_name,
+            action: 'show',
+            id: '1'
+          )
         end
 
-        it 'accepts when format is specified as a symbol' do
-          expect(controller_with_defined_routes).
-            to route(:post, "/#{controller_path}").
-            to(action: 'create', format: :json)
+        context 'but its value was not specified as a string' do
+          it 'accepts, treating it as a string' do
+            define_route :get, "/#{controller_name}/:id", action: 'show'
+
+            assert_accepts add_target_to(
+              route(:get, "/#{controller_name}/1"),
+              controller: controller_name,
+              action: 'show',
+              id: 1
+            )
+          end
         end
+      end
 
-        it 'rejects when format is unspecified' do
-          expect(controller_with_defined_routes).
-            not_to route(:post, "/#{controller_path}").
-            to(action: 'create')
+      context 'and the expected params do not match the actual params' do
+        it 'rejects' do
+          define_route :get, "/#{controller_name}/:id", action: 'show'
+
+          params = {
+            controller: controller_name,
+            action: 'show',
+            some: 'other',
+            params: 'here'
+          }
+          assert_rejects add_target_to(
+            route(:get, "/#{controller_name}/:id"),
+            params
+          )
         end
       end
     end
 
-    context 'when controller and action are specified as a joined string' do
-      it 'accepts' do
-        expect(controller_with_defined_routes).
-          to route(:get, "/#{controller_path}").
-          to("#{controller_path}#index")
-      end
+    context 'when the actual route has a default param whose value is a symbol' do
+      context 'and the expected params include a value for it' do
+        context 'as a symbol' do
+          it 'accepts' do
+            define_route :post, "/#{controller_name}/(.:format)",
+              action: 'create',
+              defaults: { format: :json }
+
+            assert_accepts add_target_to(
+              route(:post, "/#{controller_name}"),
+              controller: controller_name,
+              action: 'create',
+              format: :json
+            )
+          end
+        end
+
+        context 'as a string' do
+          it 'accepts' do
+            define_route :post, "/#{controller_name}/(.:format)",
+              action: 'create',
+              defaults: { format: :json }
 
-      context 'when route has parameters' do
-        it 'accepts a non-string parameter' do
-          expect(controller_with_defined_routes).
-            to route(:get, "/#{controller_path}/1").
-            to("#{controller_path}#show", id: 1)
+            assert_accepts add_target_to(
+              route(:post, "/#{controller_name}"),
+              controller: controller_name,
+              action: 'create',
+              format: 'json'
+            )
+          end
         end
       end
+    end
 
-      context 'when route has the format' do
+    context 'when the existing route has a glob segment' do
+      context 'and a param is given which represents the segment' do
         it 'accepts' do
-          expect(controller_with_defined_routes).
-            to route(:post, "/#{controller_path}").
-            to("#{controller_path}#create", format: 'json')
+          define_route :get, "/#{controller_name}/*id", action: 'whatever'
+
+          assert_accepts add_target_to(
+            route(:get, "/#{controller_name}/foo/bar"),
+            controller: controller_name,
+            action: 'whatever',
+            id: 'foo/bar'
+          )
         end
+      end
+
+      context 'and no param is given which represents the segment' do
+        it 'rejects' do
+          define_route :get, "/#{controller_name}/*id", action: 'whatever'
 
-        it 'rejects when format is unspecified' do
-          expect(controller_with_defined_routes).
-            not_to route(:post, "/#{controller_path}").
-            to(action: 'create')
+          assert_rejects add_target_to(
+            route(:get, "/#{controller_name}"),
+            controller: controller_name,
+            action: 'whatever'
+          )
         end
       end
     end
+  end
 
-    def controller_with_defined_routes
-      @_controller_with_defined_routes ||= begin
-        controller_class = define_controller(controller_name)
-        _controller_path = controller_path
-
-        setup_rails_controller_test(controller_class)
+  shared_examples_for 'core tests' do
+    context 'given a controller and action specified as individual options' do
+      include_examples 'tests involving expected route parts',
+        include_controller_in_expected_route_options: true
 
-        define_routes do
-          get "/#{_controller_path}", to: "#{_controller_path}#index"
-          get "/#{_controller_path}/:id", to: "#{_controller_path}#show"
-          post "/#{_controller_path}",
-            to: "#{_controller_path}#create",
-            defaults: { format: :json }
-        end
+      include_examples 'tests involving params'
 
-        controller
+      def add_target_to(route_matcher, params)
+        route_matcher.to(params)
       end
     end
 
-    def controller_path
-      controller_name.sub(/Controller$/, '').underscore
+    context 'given a controller and action joined together in a string' do
+      include_examples 'tests involving expected route parts',
+        include_controller_in_expected_route_options: true
+
+      include_examples 'tests involving params'
+
+      def add_target_to(route_matcher, args)
+        controller = args.fetch(:controller)
+        action = args.fetch(:action)
+        route_matcher.to("#{controller}##{action}", args)
+      end
     end
 
-    alias_method :define_controller_with_defined_routes,
-      :controller_with_defined_routes
-  end
+    context 'given just an action' do
+      include_examples 'tests involving expected route parts',
+        include_controller_in_expected_route_options: false
 
-  context 'given a controller with a defined glob url' do
-    it 'accepts glob route' do
-      controller_class = define_controller('Examples')
-      setup_rails_controller_test(controller_class)
+      include_examples 'tests involving params'
 
-      define_routes do
-        get '/examples/*id', to: 'examples#example'
+      def add_target_to(route_matcher, params)
+        route_matcher.to(params)
       end
-
-      expect(controller).to route(:get, '/examples/foo/bar').
-        to(action: 'example', id: 'foo/bar')
     end
   end
 
+  before do
+    setup_rails_controller_test(controller_class)
+  end
+
   context 'given a controller that is not namespaced' do
-    it_behaves_like 'a controller with a defined route' do
-      def controller_name
-        'ExamplesController'
-      end
+    include_examples 'core tests'
+
+    def controller_class_name
+      'ExamplesController'
     end
   end
 
   context 'given a controller that is namespaced' do
-    it_behaves_like 'a controller with a defined route' do
-      before do
-        define_module('Admin')
-      end
+    def define_controller_under_test
+      define_module('Admin')
+      super
+    end
+
+    include_examples 'core tests'
 
-      def controller_name
-        'Admin::ExamplesController'
+    def controller_class_name
+      'Admin::ExamplesController'
+    end
+  end
+
+  let(:controller_class) do
+    define_controller_under_test
+  end
+
+  def define_controller_under_test
+    define_controller(controller_class_name)
+  end
+
+  def controller_name
+    controller_class_name.sub(/Controller$/, '').underscore
+  end
+
+  def define_route(method, path, args)
+    action = args.fetch(:action)
+    controller = args.fetch(:controller) { controller_name }
+    define_routes do
+      public_send(
+        method,
+        path,
+        args.merge(controller: controller, action: action)
+      )
+    end
+  end
+
+  def build_expected_route_options(include_controller_in_expected_route_options, default_options)
+    default_options.dup.tap do |options|
+      if include_controller_in_expected_route_options
+        options[:controller] = controller_name
       end
     end
   end
+
+  def assert_accepts(matcher)
+    expect(controller).to matcher
+  end
+
+  def assert_rejects(matcher)
+    expect(controller).not_to matcher
+  end
 end