shoulda-matchers 3.0.0.rc1 → 3.0.0

data/lib/shoulda/matchers.rb

@@ -12,6 +12,7 @@ require 'shoulda/matchers/warn'
 require 'shoulda/matchers/action_controller'
 require 'shoulda/matchers/active_model'
 require 'shoulda/matchers/active_record'
+require 'shoulda/matchers/routing'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/action_controller/callback_matcher.rb

@@ -14,7 +14,7 @@ module Shoulda
       #       it { should_not use_before_filter(:prevent_ssl) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UsersControllerTest < ActionController::TestCase
       #       should use_before_filter(:authenticate_user!)
       #       should_not use_before_filter(:prevent_ssl)
@@ -39,7 +39,7 @@ module Shoulda
       #       it { should_not use_after_filter(:destroy_user) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class IssuesControllerTest < ActionController::TestCase
       #       should use_after_filter(:log_activity)
       #       should_not use_after_filter(:destroy_user)
@@ -64,7 +64,7 @@ module Shoulda
       #       it { should_not use_before_action(:prevent_ssl) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UsersControllerTest < ActionController::TestCase
       #       should use_before_action(:authenticate_user!)
       #       should_not use_before_action(:prevent_ssl)
@@ -89,7 +89,7 @@ module Shoulda
       #       it { should_not use_after_action(:destroy_user) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class IssuesControllerTest < ActionController::TestCase
       #       should use_after_action(:log_activity)
       #       should_not use_after_action(:destroy_user)
@@ -114,7 +114,7 @@ module Shoulda
       #       it { should_not use_around_filter(:save_view_context) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class ChangesControllerTest < ActionController::TestCase
       #       should use_around_filter(:wrap_in_transaction)
       #       should_not use_around_filter(:save_view_context)
@@ -139,7 +139,7 @@ module Shoulda
       #       it { should_not use_around_action(:save_view_context) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class ChangesControllerTest < ActionController::TestCase
       #       should use_around_action(:wrap_in_transaction)
       #       should_not use_around_action(:save_view_context)
@@ -169,12 +169,10 @@ module Shoulda
         def failure_message
           "Expected that #{controller_class.name} would have :#{method_name} as a #{kind}_#{callback_type}"
         end
-        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "Expected that #{controller_class.name} would not have :#{method_name} as a #{kind}_#{callback_type}"
         end
-        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           "have :#{method_name} as a #{kind}_#{callback_type}"

data/lib/shoulda/matchers/action_controller/filter_param_matcher.rb

@@ -14,7 +14,7 @@ module Shoulda
       #       it { should filter_param(:secret_key) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class ApplicationControllerTest < ActionController::TestCase
       #       should filter_param(:secret_key)
       #     end
@@ -38,12 +38,10 @@ module Shoulda
         def failure_message
           "Expected #{@key} to be filtered; filtered keys: #{filtered_keys.join(', ')}"
         end
-        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "Did not expect #{@key} to be filtered"
         end
-        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           "filter #{@key}"

data/lib/shoulda/matchers/action_controller/flash_store.rb

@@ -26,7 +26,7 @@ module Shoulda
         end
 
         def has_key?(key)
-          values_to_check.include?(key)
+          values_to_check.include?(key.to_s)
         end
 
         def has_value?(expected_value)
@@ -54,7 +54,6 @@ module Shoulda
           controller.flash.dup.tap do |flash|
             copy_flashes(controller.flash, flash)
             copy_discard_if_necessary(controller.flash, flash)
-            # sweep_flash_if_necessary(flash)
           end
         end
 
@@ -68,12 +67,6 @@ module Shoulda
           new_flash.instance_variable_set('@discard', discard)
         end
 
-        def sweep_flash_if_necessary(flash)
-          unless @use_now
-            flash.sweep
-          end
-        end
-
         def set_values
           flash.instance_variable_get('@flashes')
         end

data/lib/shoulda/matchers/action_controller/permit_matcher.rb

@@ -37,17 +37,35 @@ module Shoulda
       #     # RSpec
       #     describe UsersController do
       #       it do
+      #         params = {
+      #           user: {
+      #             first_name: 'John',
+      #             last_name: 'Doe',
+      #             email: 'johndoe@example.com',
+      #             password: 'password'
+      #           }
+      #         }
       #         should permit(:first_name, :last_name, :email, :password).
-      #           for(:create).
+      #           for(:create, params: params).
       #           on(:user)
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UsersControllerTest < ActionController::TestCase
-      #       should permit(:first_name, :last_name, :email, :password).
-      #         for(:create).
-      #         on(:user)
+      #       should "(for POST #create) restrict parameters on :user to first_name, last_name, email, and password" do
+      #         params = {
+      #           user: {
+      #             first_name: 'John',
+      #             last_name: 'Doe',
+      #             email: 'johndoe@example.com',
+      #             password: 'password'
+      #           }
+      #         }
+      #         should permit(:first_name, :last_name, :email, :password).
+      #           for(:create, params: params).
+      #           on(:user)
+      #       end
       #     end
       #
       # If your action requires query parameters in order to work, then you'll
@@ -83,21 +101,41 @@ module Shoulda
       #       end
       #
       #       it do
+      #         params = {
+      #           id: 1,
+      #           user: {
+      #             first_name: 'Jon',
+      #             last_name: 'Doe',
+      #             email: 'jondoe@example.com',
+      #             password: 'password'
+      #           }
+      #         }
       #         should permit(:first_name, :last_name, :email, :password).
-      #           for(:update, params: { id: 1 }).
+      #           for(:update, params: params).
       #           on(:user)
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UsersControllerTest < ActionController::TestCase
       #       setup do
       #         create(:user, id: 1)
       #       end
       #
-      #       should permit(:first_name, :last_name, :email, :password).
-      #         for(:update, params: { id: 1 }).
-      #         on(:user)
+      #       should "(for PATCH #update) restrict parameters on :user to :first_name, :last_name, :email, and :password" do
+      #         params = {
+      #           id: 1,
+      #           user: {
+      #             first_name: 'Jon',
+      #             last_name: 'Doe',
+      #             email: 'jondoe@example.com',
+      #             password: 'password'
+      #           }
+      #         }
+      #         should permit(:first_name, :last_name, :email, :password).
+      #           for(:update, params: params).
+      #           on(:user)
+      #       end
       #     end
       #
       # Finally, if you have an action that isn't one of the seven resourceful
@@ -136,21 +174,25 @@ module Shoulda
       #       end
       #
       #       it do
+      #         params = { id: 1, user: { activated: true } }
       #         should permit(:activated).
-      #           for(:toggle, params: { id: 1 }, verb: :put).
+      #           for(:toggle, params: params, verb: :put).
       #           on(:user)
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UsersControllerTest < ActionController::TestCase
       #       setup do
       #         create(:user, id: 1)
       #       end
       #
-      #       should permit(:activated).
-      #         for(:toggle, params: { id: 1 }, verb: :put).
-      #         on(:user)
+      #       should "(for PUT #toggle) restrict parameters on :user to :activated" do
+      #         params = { id: 1, user: { activated: true } }
+      #         should permit(:activated).
+      #           for(:toggle, params: params, verb: :put).
+      #           on(:user)
+      #       end
       #     end
       #
       # @return [PermitMatcher]
@@ -163,13 +205,13 @@ module Shoulda
       class PermitMatcher
         attr_writer :stubbed_params
 
-        def initialize(expected_permitted_params)
-          @expected_permitted_params = expected_permitted_params
+        def initialize(expected_permitted_parameter_names)
+          @expected_permitted_parameter_names = expected_permitted_parameter_names
           @action = nil
           @verb = nil
           @request_params = {}
-          @subparameter = nil
-          @parameters_doubles = ParametersDoubles.new
+          @subparameter_name = nil
+          @parameters_double_registry = CompositeParametersDoubleRegistry.new
         end
 
         def for(action, options = {})
@@ -184,9 +226,8 @@ module Shoulda
           self
         end
 
-        def on(subparameter)
-          @subparameter = subparameter
-          @parameters_doubles = SliceOfParametersDoubles.new(subparameter)
+        def on(subparameter_name)
+          @subparameter_name = subparameter_name
           self
         end
 
@@ -196,78 +237,84 @@ module Shoulda
         end
 
         def description
-          "(on #{verb.upcase} ##{action}) " + expectation
+          "(for #{verb.upcase} ##{action}) " + expectation
         end
 
         def matches?(controller)
           @controller = controller
           ensure_action_and_verb_present!
 
-          parameters_doubles.register
+          parameters_double_registry.register
 
           Doublespeak.with_doubles_activated do
             context.__send__(verb, action, request_params)
           end
 
-          unpermitted_params.empty?
+          unpermitted_parameter_names.empty?
         end
 
         def failure_message
           "Expected #{verb.upcase} ##{action} to #{expectation},\nbut #{reality}."
         end
-        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "Expected #{verb.upcase} ##{action} not to #{expectation},\nbut it did."
         end
-        alias failure_message_for_should_not failure_message_when_negated
 
         protected
 
-        attr_reader :controller, :double_collections_by_param, :action, :verb,
-          :request_params, :expected_permitted_params, :context, :subparameter,
-          :parameters_doubles
+        attr_reader :controller, :double_collections_by_parameter_name, :action, :verb,
+          :request_params, :expected_permitted_parameter_names, :context, :subparameter_name,
+          :parameters_double_registry
 
         def expectation
           message = 'restrict parameters '
 
-          if subparameter
-            message << " for #{subparameter.inspect}"
+          if subparameter_name
+            message << "on #{subparameter_name.inspect} "
           end
 
-          message << 'to ' + format_param_names(expected_permitted_params)
+          message << 'to ' + format_parameter_names(expected_permitted_parameter_names)
 
           message
         end
 
         def reality
-          if actual_permitted_params.empty?
+          if actual_permitted_parameter_names.empty?
             'it did not restrict any parameters'
           else
             'the restricted parameters were ' +
-              format_param_names(actual_permitted_params) +
+              format_parameter_names(actual_permitted_parameter_names) +
               ' instead'
           end
         end
 
-        def format_param_names(param_names)
-          param_names.map(&:inspect).to_sentence
+        def format_parameter_names(parameter_names)
+          parameter_names.map(&:inspect).to_sentence
         end
 
-        def actual_permitted_params
-          parameters_doubles.permitted_params
+        def actual_permitted_parameter_names
+          @_actual_permitted_parameter_names ||= begin
+            if subparameter_name
+              options = { for: subparameter_name }
+            else
+              options = {}
+            end
+
+            parameters_double_registry.permitted_parameter_names(options)
+          end
         end
 
         def permit_called?
-          actual_permitted_params.any?
+          actual_permitted_parameter_names.any?
         end
 
-        def unpermitted_params
-          expected_permitted_params - actual_permitted_params
+        def unpermitted_parameter_names
+          expected_permitted_parameter_names - actual_permitted_parameter_names
         end
 
-        def verified_permitted_params
-          expected_permitted_params & actual_permitted_params
+        def verified_permitted_parameter_names
+          expected_permitted_parameter_names & actual_permitted_parameter_names
         end
 
         def ensure_action_and_verb_present!
@@ -287,57 +334,63 @@ module Shoulda
           end
         end
 
-        def param_names_as_sentence
-          expected_permitted_params.map(&:inspect).to_sentence
+        def parameter_names_as_sentence
+          expected_permitted_parameter_names.map(&:inspect).to_sentence
         end
 
         # @private
-        class ParametersDoubles
-          def self.permitted_params_within(double_collection)
-            double_collection.calls_to(:permit).map(&:args).flatten
-          end
-
+        class CompositeParametersDoubleRegistry
           def initialize
-            klass = ::ActionController::Parameters
-            @double_collection = Doublespeak.double_collection_for(klass)
+            @parameters_double_registries_by_params = {}
           end
 
           def register
-            double_collection.register_proxy(:permit)
+            double_collection = Doublespeak.double_collection_for(
+              ::ActionController::Parameters.singleton_class
+            )
+            double_collection.register_proxy(:new).to_return do |call|
+              params = call.return_value
+              parameters_double_registry = ParametersDoubleRegistry.new(params)
+              parameters_double_registry.register
+              parameters_double_registries_by_params[params] =
+                parameters_double_registry
+            end
           end
 
-          def permitted_params
-            ParametersDoubles.permitted_params_within(double_collection)
+          def permitted_parameter_names(options = {})
+            parameters_double_registries_by_params.flat_map do |params, double_registry|
+              double_registry.permitted_parameter_names(options)
+            end
           end
 
           protected
 
-          attr_reader :double_collection
+          attr_reader :parameters_double_registries_by_params
         end
 
         # @private
-        class SliceOfParametersDoubles
+        class ParametersDoubleRegistry
           TOP_LEVEL = Object.new
 
-          def initialize(subparameter)
-            klass = ::ActionController::Parameters
+          def self.permitted_parameter_names_within(double_collection)
+            double_collection.calls_to(:permit).map(&:args).flatten
+          end
 
-            @subparameter = subparameter
-            @double_collections_by_param = {
-              TOP_LEVEL => Doublespeak.double_collection_for(klass)
-            }
+          def initialize(params)
+            @params = params
+            @double_collections_by_parameter_name = {}
           end
 
           def register
-            top_level_collection = double_collections_by_param[TOP_LEVEL]
-            double_permit_on(top_level_collection)
-            double_require_on(top_level_collection)
+            register_double_for_permit_against(params, TOP_LEVEL)
           end
 
-          def permitted_params
-            if double_collections_by_param.key?(subparameter)
-              ParametersDoubles.permitted_params_within(
-                double_collections_by_param[subparameter]
+          def permitted_parameter_names(args = {})
+            subparameter_name = args.fetch(:for, TOP_LEVEL)
+
+            if double_collections_by_parameter_name.key?(subparameter_name)
+              self.class.permitted_parameter_names_within(
+                double_collections_by_parameter_name[subparameter_name]
               )
             else
               []
@@ -346,31 +399,30 @@ module Shoulda
 
           protected
 
-          attr_reader :subparameter, :double_collections_by_param
+          attr_reader :params, :double_collections_by_parameter_name
 
           private
 
-          def double_permit_on(double_collection)
-            double_collection.register_proxy(:permit)
-          end
+          def register_double_for_permit_against(params, subparameter_name)
+            klass = params.singleton_class
 
-          def double_require_on(double_collection)
-            double_collections_by_param = @double_collections_by_param
-            require_double = double_collection.register_proxy(:require)
+            double_collection = Doublespeak.double_collection_for(klass)
+            register_double_for_permit_on(double_collection)
+            register_double_for_require_on(double_collection)
 
-            require_double.to_return do |call|
-              param_name = call.args.first
-              params = call.return_value
-              double_collections_by_param[param_name] ||=
-                double_permit_against(params)
-            end
+            double_collections_by_parameter_name[subparameter_name] =
+              double_collection
           end
 
-          def double_permit_against(params)
-            klass = params.singleton_class
+          def register_double_for_permit_on(double_collection)
+            double_collection.register_proxy(:permit)
+          end
 
-            Doublespeak.double_collection_for(klass).tap do |double_collection|
-              double_permit_on(double_collection)
+          def register_double_for_require_on(double_collection)
+            double_collection.register_proxy(:require).to_return do |call|
+              params = call.return_value
+              subparameter_name = call.args.first
+              register_double_for_permit_against(params, subparameter_name)
             end
           end
         end