mcmire-shoulda-matchers 2.5.0 → 2.6.1.docs.1

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

@@ -0,0 +1,165 @@
+require 'delegate'
+
+begin
+  require 'strong_parameters'
+rescue LoadError
+end
+
+require 'active_support/hash_with_indifferent_access'
+
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `permit` matcher tests usage of strong parameters, specifically
+      # its #permit method.
+      #
+      #     class UsersController < ApplicationController
+      #       def create
+      #         user = User.new(user_params)
+      #
+      #         if user.save
+      #           # ...
+      #         else
+      #           # ...
+      #         end
+      #       end
+      #
+      #       private
+      #
+      #       def user_params
+      #         require(:user).permit(:email, :password)
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe UsersController do
+      #       it { should permit(:email, :password).for(:user) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UsersControllerTest < ActionController::TestCase
+      #       should permit(:email, :password).for(:user)
+      #     end
+      #
+      def permit(*params)
+        StrongParametersMatcher.new(params).in_context(self)
+      end
+
+      # @private
+      class StrongParametersMatcher
+        attr_writer :stubbed_params
+
+        def initialize(expected_permitted_params)
+          @action = nil
+          @verb = nil
+          @request_params = {}
+          @expected_permitted_params = expected_permitted_params
+          set_double_collection
+        end
+
+        def for(action, options = {})
+          @action = action
+          @verb = options.fetch(:verb, default_verb)
+          @request_params = options.fetch(:params, {})
+          self
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def description
+          "permit #{verb.upcase} ##{action} to receive parameters #{param_names_as_sentence}"
+        end
+
+        def matches?(controller)
+          @controller = controller
+          ensure_action_and_verb_present!
+
+          Doublespeak.with_doubles_activated do
+            context.__send__(verb, action, request_params)
+          end
+
+          unpermitted_params.empty?
+        end
+
+        def failure_message
+          "Expected controller to permit #{unpermitted_params.to_sentence}, but it did not."
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          "Expected controller not to permit #{verified_permitted_params.to_sentence}, but it did."
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        private
+
+        attr_reader :controller, :double_collection, :action, :verb,
+          :request_params, :expected_permitted_params, :context
+
+        def set_double_collection
+          @double_collection =
+            Doublespeak.register_double_collection(::ActionController::Parameters)
+
+          @double_collection.register_stub(:require).to_return { |params| params }
+          @double_collection.register_proxy(:permit)
+        end
+
+        def actual_permitted_params
+          double_collection.calls_to(:permit).inject([]) do |all_param_names, call|
+            all_param_names + call.args
+          end.flatten
+        end
+
+        def permit_called?
+          actual_permitted_params.any?
+        end
+
+        def unpermitted_params
+          expected_permitted_params - actual_permitted_params
+        end
+
+        def verified_permitted_params
+          expected_permitted_params & actual_permitted_params
+        end
+
+        def ensure_action_and_verb_present!
+          if action.blank?
+            raise ActionNotDefinedError
+          end
+
+          if verb.blank?
+            raise VerbNotDefinedError
+          end
+        end
+
+        def default_verb
+          case action
+            when :create then :post
+            when :update then RailsShim.verb_for_update
+          end
+        end
+
+        def param_names_as_sentence
+          expected_permitted_params.map(&:inspect).to_sentence
+        end
+
+        # @private
+        class ActionNotDefinedError < StandardError
+          def message
+            'You must specify the controller action using the #for method.'
+          end
+        end
+
+        # @private
+        class VerbNotDefinedError < StandardError
+          def message
+            'You must specify an HTTP verb when using a non-RESTful action. For example: for(:authorize, verb: :post)'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/action_controller.rb

@@ -8,6 +8,8 @@ require 'shoulda/matchers/action_controller/route_matcher'
 require 'shoulda/matchers/action_controller/redirect_to_matcher'
 require 'shoulda/matchers/action_controller/render_template_matcher'
 require 'shoulda/matchers/action_controller/rescue_from_matcher'
+require 'shoulda/matchers/action_controller/callback_matcher'
+require 'shoulda/matchers/action_controller/strong_parameters_matcher'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/active_model/allow_value_matcher.rb

@@ -169,6 +169,7 @@ module Shoulda
           self.values_to_match = values
           self.message_finder_factory = ValidationMessageFinder
           self.options = {}
+          self.after_setting_value_callback = -> {}
         end
 
         def for(attribute)
@@ -184,9 +185,12 @@ module Shoulda
 
         def with_message(message, options={})
           self.options[:expected_message] = message
+          self.options[:expected_message_values] = options.fetch(:values, {})
+
           if options.key?(:against)
             self.attribute_to_check_message_against = options[:against]
           end
+
           self
         end
 
@@ -195,12 +199,17 @@ module Shoulda
           self
         end
 
+        # @private
+        def _after_setting_value(&callback)
+          self.after_setting_value_callback = callback
+        end
+
         def matches?(instance)
           self.instance = instance
 
           values_to_match.none? do |value|
             self.value = value
-            instance.__send__("#{attribute_to_set}=", value)
+            set_value(value)
             errors_match?
           end
         end
@@ -223,7 +232,12 @@ module Shoulda
 
         attr_accessor :values_to_match, :message_finder_factory,
           :instance, :attribute_to_set, :attribute_to_check_message_against,
-          :context, :value, :matched_error
+          :context, :value, :matched_error, :after_setting_value_callback
+
+        def set_value(value)
+          instance.__send__("#{attribute_to_set}=", value)
+          after_setting_value_callback.call
+        end
 
         def errors_match?
           has_messages? && errors_for_attribute_match?
@@ -295,10 +309,18 @@ module Shoulda
         def default_attribute_message
           default_error_message(
             options[:expected_message],
+            default_attribute_message_values
+          )
+        end
+
+        def default_attribute_message_values
+          defaults = {
             model_name: model_name,
             instance: instance,
-            attribute: attribute_to_set
-          )
+            attribute: attribute_to_set,
+          }
+
+          defaults.merge(options[:expected_message_values])
         end
 
         def model_name

data/lib/shoulda/matchers/active_model/disallow_value_matcher.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Shoulda
   module Matchers
     module ActiveModel
@@ -40,6 +42,10 @@ module Shoulda
           @allow_matcher.strict
           self
         end
+
+        private
+
+        attr_reader :allow_matcher
       end
     end
   end

data/lib/shoulda/matchers/active_model/ensure_exclusion_of_matcher.rb

@@ -56,6 +56,8 @@ module Shoulda
       # Use `with_message` if you are using a custom validation message.
       #
       #     class Game
+      #       include ActiveModel::Model
+      #
       #       validates_exclusion_of :weapon,
       #         in: ['pistol', 'paintball gun', 'stick'],
       #         message: 'You chose a puny weapon'

data/lib/shoulda/matchers/active_model/ensure_inclusion_of_matcher.rb

@@ -1,3 +1,5 @@
+require 'bigdecimal'
+
 module Shoulda
   module Matchers
     module ActiveModel
@@ -216,7 +218,7 @@ module Shoulda
       class EnsureInclusionOfMatcher < ValidationMatcher
         ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
         ARBITRARY_OUTSIDE_FIXNUM = 123456789
-        ARBITRARY_OUTSIDE_DECIMAL = 0.123456789
+        ARBITRARY_OUTSIDE_DECIMAL = BigDecimal.new('0.123456789')
         BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT
 You are using `ensure_inclusion_of` to assert that a boolean column allows
 boolean values and disallows non-boolean ones. Assuming you are using
@@ -230,11 +232,6 @@ You are using `ensure_inclusion_of` to assert that a boolean column allows nil.
 Be aware that it is not possible to fully test this, as anything other than
 true, false or nil will be converted to false. Hence, you should consider
 removing this test and the corresponding validation.
-EOT
-        BOOLEAN_ALLOWS_NIL_WITH_NOT_NULL_MESSAGE = <<EOT
-You have specified that your model's #{@attribute} should ensure inclusion of nil.
-However, #{@attribute} is a boolean column which does not allow null values.
-Hence, this test will fail and there is no way to make it pass.
 EOT
 
         def initialize(attribute)
@@ -292,13 +289,9 @@ EOT
           if @range
             @low_message  ||= :inclusion
             @high_message ||= :inclusion
-
-            disallows_lower_value &&
-              allows_minimum_value &&
-              disallows_higher_value &&
-              allows_maximum_value
+            matches_for_range?
           elsif @array
-            if allows_all_values_in_array? && allows_blank_value? && allows_nil_value? && disallows_value_outside_of_array?
+            if matches_for_array?
               true
             else
               @failure_message = "#{@array} doesn't match array in validation"
@@ -309,6 +302,20 @@ EOT
 
         private
 
+        def matches_for_range?
+          disallows_lower_value &&
+            allows_minimum_value &&
+            disallows_higher_value &&
+            allows_maximum_value
+        end
+
+        def matches_for_array?
+          allows_all_values_in_array? &&
+            allows_blank_value? &&
+            allows_nil_value? &&
+            disallows_value_outside_of_array?
+        end
+
         def allows_blank_value?
           if @options.key?(:allow_blank)
             blank_values = ['', ' ', "\n", "\r", "\t", "\f"]
@@ -353,7 +360,7 @@ EOT
         end
 
         def disallows_value_outside_of_array?
-          if attribute_column.type == :boolean
+          if attribute_type == :boolean
             case @array
             when [true, false]
               Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
@@ -363,7 +370,7 @@ EOT
                 Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
                 return true
               else
-                raise NonNullableBooleanError, BOOLEAN_ALLOWS_NIL_WITH_NOT_NULL_MESSAGE
+                raise NonNullableBooleanError.create(@attribute)
               end
             end
           end
@@ -380,10 +387,10 @@ EOT
         end
 
         def outside_values
-          case attribute_column.type
+          case attribute_type
           when :boolean
             boolean_outside_values
-          when :integer, :float
+          when :fixnum
             [ARBITRARY_OUTSIDE_FIXNUM]
           when :decimal
             [ARBITRARY_OUTSIDE_DECIMAL]
@@ -401,15 +408,50 @@ EOT
             else              raise CouldNotDetermineValueOutsideOfArray
           end
 
-          if attribute_column.null
+          if attribute_allows_nil?
             values << nil
           end
 
           values
         end
 
+        def attribute_type
+          if attribute_column
+            column_type_to_attribute_type(attribute_column.type)
+          else
+            value_to_attribute_type(@subject.__send__(@attribute))
+          end
+        end
+
+        def attribute_allows_nil?
+          if attribute_column
+            attribute_column.null
+          else
+            true
+          end
+        end
+
         def attribute_column
-          @subject.class.columns_hash[@attribute.to_s]
+          if @subject.class.respond_to?(:columns_hash)
+            @subject.class.columns_hash[@attribute.to_s]
+          end
+        end
+
+        def column_type_to_attribute_type(type)
+          case type
+            when :boolean, :decimal then type
+            when :integer, :float then :fixnum
+            else :default
+          end
+        end
+
+        def value_to_attribute_type(value)
+          case value
+            when true, false then :boolean
+            when BigDecimal then :decimal
+            when Fixnum then :fixnum
+            else :default
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_model/errors.rb

@@ -3,8 +3,50 @@ module Shoulda
     module ActiveModel
       # @private
       class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
+
       # @private
-      class NonNullableBooleanError < Shoulda::Matchers::Error; end
+      class NonNullableBooleanError < Shoulda::Matchers::Error
+        def self.create(attribute)
+          super(attribute: attribute)
+        end
+
+        attr_accessor :attribute
+
+        def message
+          <<-EOT.strip
+You have specified that your model's #{attribute} should ensure inclusion of nil.
+However, #{attribute} is a boolean column which does not allow null values.
+Hence, this test will fail and there is no way to make it pass.
+          EOT
+        end
+      end
+
+      # @private
+      class CouldNotSetPasswordError < Shoulda::Matchers::Error
+        def self.create(model)
+          super(model: model)
+        end
+
+        attr_accessor :model
+
+        def message
+          <<-EOT.strip
+The validation failed because your #{model_name} model declares `has_secure_password`, and
+`validate_presence_of` was called on a #{record_name} which has `password` already set to a value.
+Please use a #{record_name} with an empty `password` instead.
+          EOT
+        end
+
+        private
+
+        def model_name
+          model.name
+        end
+
+        def record_name
+          model_name.humanize.downcase
+        end
+      end
     end
   end
 end

data/lib/shoulda/matchers/active_model/numericality_matchers/comparison_matcher.rb

@@ -4,6 +4,14 @@ module Shoulda
       module NumericalityMatchers
         # @private
         class ComparisonMatcher < ValidationMatcher
+          ERROR_MESSAGES = {
+            :> => :greater_than,
+            :>= => :greater_than_or_equal_to,
+            :< => :less_than,
+            :<= => :less_than_or_equal_to,
+            :== => :equal_to
+          }
+
           def initialize(numericality_matcher, value, operator)
             unless numericality_matcher.respond_to? :diff_to_compare
               raise ArgumentError, 'numericality_matcher is invalid'
@@ -11,7 +19,8 @@ module Shoulda
             @numericality_matcher = numericality_matcher
             @value = value
             @operator = operator
-            @message = nil
+            @message = ERROR_MESSAGES[operator]
+            @comparison_combos = comparison_combos
           end
 
           def for(attribute)
@@ -64,8 +73,10 @@ module Shoulda
           end
 
           def all_bounds_correct?
-            comparison_combos.all? do |diff, checker_type|
-              __send__(checker_type, @value + diff, @message)
+            @comparison_combos.all? do |diff, checker_type|
+              __send__(checker_type, @value + diff) do |matcher|
+                matcher.with_message(@message, values: { count: @value })
+              end
             end
           end
         end

data/lib/shoulda/matchers/active_model/validate_absence_of_matcher.rb

@@ -29,7 +29,8 @@ module Shoulda
       #     class Artillery
       #       include ActiveModel::Model
       #
-      #       validates_absence_of :arms, message: "We're fresh outta arms here, soldier!"
+      #       validates_absence_of :arms,
+      #         message: "We're fresh outta arms here, soldier!"
       #     end
       #
       #     # RSpec