shoulda-matchers 2.5.0 → 2.6.0

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

@@ -46,7 +46,7 @@ module Shoulda # :nodoc:
 
         def redirects_to_url?
           begin
-            @context.send(:assert_redirected_to, url)
+            @context.__send__(:assert_redirected_to, url)
             @failure_message_when_negated = "Didn't expect to redirect to #{url}"
             true
           rescue Shoulda::Matchers::AssertionError => error

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

@@ -8,13 +8,13 @@ module Shoulda # :nodoc:
       #   it { should render_template(:show)  }
       #
       #   assert that the "_customer" partial was rendered
-      #   it { should render_template(:partial => '_customer')  }
+      #   it { should render_template(partial: '_customer')  }
       #
       #   assert that the "_customer" partial was rendered twice
-      #   it { should render_template(:partial => '_customer', :count => 2)  }
+      #   it { should render_template(partial: '_customer', count: 2)  }
       #
       #   assert that no partials were rendered
-      #   it { should render_template(:partial => false)  }
+      #   it { should render_template(partial: false)  }
       def render_template(options = {}, message = nil)
         RenderTemplateMatcher.new(options, message, self)
       end
@@ -50,7 +50,7 @@ module Shoulda # :nodoc:
 
         def renders_template?
           begin
-            @context.send(:assert_template, @options, @message)
+            @context.__send__(:assert_template, @options, @message)
             @failure_message_when_negated = "Didn't expect to render #{@template}"
             true
           rescue Shoulda::Matchers::AssertionError => error

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

@@ -72,7 +72,7 @@ module Shoulda
 
         def handler_exists?
           if expected_method.present?
-            controller.respond_to? expected_method
+            controller.respond_to? expected_method, true
           else
             true
           end

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

@@ -12,20 +12,20 @@ module Shoulda # :nodoc:
       # Examples:
       #
       #   it { should route(:get, '/posts').
-      #                 to(:controller => :posts, :action => :index) }
+      #                 to(controller: :posts, action: :index) }
       #   it { should route(:get, '/posts').to('posts#index') }
-      #   it { should route(:get, '/posts/new').to(:action => :new) }
-      #   it { should route(:post, '/posts').to(:action => :create) }
-      #   it { should route(:get, '/posts/1').to(:action => :show, :id => 1) }
-      #   it { should route(:get, '/posts/1').to('posts#show', :id => 1) }
-      #   it { should route(:get, '/posts/1/edit').to(:action => :edit, :id => 1) }
-      #   it { should route(:put, '/posts/1').to(:action => :update, :id => 1) }
+      #   it { should route(:get, '/posts/new').to(action: :new) }
+      #   it { should route(:post, '/posts').to(action: :create) }
+      #   it { should route(:get, '/posts/1').to(action: :show, id: 1) }
+      #   it { should route(:get, '/posts/1').to('posts#show', id: 1) }
+      #   it { should route(:get, '/posts/1/edit').to(action: :edit, id: 1) }
+      #   it { should route(:put, '/posts/1').to(action: :update, id: 1) }
       #   it { should route(:delete, '/posts/1').
-      #                 to(:action => :destroy, :id => 1) }
+      #                 to(action: :destroy, id: 1) }
       #   it { should route(:get, '/users/1/posts/1').
-      #                 to(:action => :show, :id => 1, :user_id => 1) }
+      #                 to(action: :show, id: 1, user_id: 1) }
       #   it { should route(:get, '/users/1/posts/1').
-      #                 to('posts#show', :id => 1, :user_id => 1) }
+      #                 to('posts#show', id: 1, user_id: 1) }
       def route(method, path)
         RouteMatcher.new(method, path, self)
       end
@@ -70,8 +70,8 @@ module Shoulda # :nodoc:
 
         def route_recognized?
           begin
-            @context.send(:assert_routing,
-                          { :method => @method, :path => @path },
+            @context.__send__(:assert_routing,
+                          { method: @method, path: @path },
                           @params)
 
             @failure_message_when_negated = "Didn't expect to #{description}"

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

@@ -25,7 +25,7 @@ module Shoulda # :nodoc:
         def extract_params_from_string
           params = args[1] || {}
           controller, action = args[0].split('#')
-          params.merge!(:controller => controller, :action => action)
+          params.merge!(controller: controller, action: action)
         end
 
         def stringify_params

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

@@ -85,7 +85,8 @@ module Shoulda # :nodoc:
 
         def flash_values
           if @options.key?(:key)
-            [flash.to_hash[@options[:key]]]
+            flash_hash = HashWithIndifferentAccess.new(flash.to_hash)
+            [flash_hash[@options[:key]]]
           else
             flash.to_hash.values
           end

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

@@ -0,0 +1,167 @@
+begin
+  require 'strong_parameters'
+rescue LoadError
+end
+
+module Shoulda
+  module Matchers
+    module ActionController
+      def permit(*attributes)
+        StrongParametersMatcher.new(self, attributes)
+      end
+
+      class StrongParametersMatcher
+        def self.stubbed_parameters_class
+          @stubbed_parameters_class ||= build_stubbed_parameters_class
+        end
+
+        def self.build_stubbed_parameters_class
+          Class.new(::ActionController::Parameters) do
+            include StubbedParameters
+          end
+        end
+
+        def initialize(context = nil, attributes)
+          @attributes = attributes
+          @context = context
+        end
+
+        def for(action, options = {})
+          @action = action
+          @verb = options[:verb] || verb_for_action
+          self
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def description
+          "permit #{verb.upcase} ##{action} to receive parameters #{attributes_as_sentence}"
+        end
+
+        def matches?(controller = nil)
+          simulate_controller_action && parameters_difference.empty?
+        end
+
+        def does_not_match?(controller = nil)
+          simulate_controller_action && parameters_intersection.empty?
+        end
+
+        def failure_message
+          "Expected controller to permit #{parameters_difference.to_sentence}, but it did not."
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          "Expected controller not to permit #{parameters_intersection.to_sentence}, but it did."
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        private
+
+        attr_reader :verb, :action, :attributes, :context
+
+        def simulate_controller_action
+          ensure_action_and_verb_present!
+          stub_model_attributes
+
+          begin
+            context.send(verb, action)
+          ensure
+            unstub_model_attributes
+          end
+
+          verify_permit_call
+        end
+
+        def verify_permit_call
+          @model_attrs.permit_was_called
+        end
+
+        def parameters_difference
+          attributes - @model_attrs.shoulda_permitted_params
+        end
+
+        def parameters_intersection
+          attributes & @model_attrs.shoulda_permitted_params
+        end
+
+        def stub_model_attributes
+          @model_attrs = self.class.stubbed_parameters_class.new(arbitrary_attributes)
+
+          local_model_attrs = @model_attrs
+          ::ActionController::Parameters.class_eval do
+            alias_method :'shoulda_original_[]', :[]
+
+            define_method :[] do |*args|
+              local_model_attrs
+            end
+          end
+        end
+
+        def unstub_model_attributes
+          ::ActionController::Parameters.class_eval do
+            alias_method :[], :'shoulda_original_[]'
+            undef_method :'shoulda_original_[]'
+          end
+        end
+
+        def ensure_action_and_verb_present!
+          if action.blank?
+            raise ActionNotDefinedError
+          end
+          if verb.blank?
+            raise VerbNotDefinedError
+          end
+        end
+
+        def arbitrary_attributes
+          {any_key: 'any_value'}
+        end
+
+        def verb_for_action
+          verb_lookup = { create: :post, update: :put }
+          verb_lookup[action]
+        end
+
+        def attributes_as_sentence
+          attributes.map(&:inspect).to_sentence
+        end
+      end
+
+      module StrongParametersMatcher::StubbedParameters
+        extend ActiveSupport::Concern
+
+        included do
+          attr_accessor :permit_was_called, :shoulda_permitted_params
+        end
+
+        def initialize(*)
+          @permit_was_called = false
+          super
+        end
+
+        def permit(*args)
+          self.shoulda_permitted_params = args
+          self.permit_was_called = true
+          nil
+        end
+      end
+
+      class StrongParametersMatcher::ActionNotDefinedError < StandardError
+        def message
+          'You must specify the controller action using the #for method.'
+        end
+      end
+
+      class StrongParametersMatcher::VerbNotDefinedError < StandardError
+        def message
+          'You must specify an HTTP verb when using a non-RESTful action.' +
+          ' e.g. for(:authorize, verb: :post)'
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model.rb

@@ -13,8 +13,10 @@ require 'shoulda/matchers/active_model/validate_uniqueness_of_matcher'
 require 'shoulda/matchers/active_model/validate_acceptance_of_matcher'
 require 'shoulda/matchers/active_model/validate_confirmation_of_matcher'
 require 'shoulda/matchers/active_model/validate_numericality_of_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher'
 require 'shoulda/matchers/active_model/numericality_matchers/comparison_matcher'
-require 'shoulda/matchers/active_model/numericality_matchers/odd_even_number_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/odd_number_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/even_number_matcher'
 require 'shoulda/matchers/active_model/numericality_matchers/only_integer_matcher'
 require 'shoulda/matchers/active_model/allow_mass_assignment_of_matcher'
 require 'shoulda/matchers/active_model/errors'
@@ -44,7 +46,7 @@ module Shoulda
     # class User < ActiveRecord::Base
     #   validates_presence_of :name
     #   validates_presence_of :phone_number
-    #   validates_inclusion_of :status, :in => %w(Activated Pending), :strict => true
+    #   validates_inclusion_of :status, in: %w(Activated Pending), strict: true
     #   attr_accessible :name, :phone_number
     # end
     module ActiveModel

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

@@ -13,7 +13,7 @@ module Shoulda # :nodoc:
       #   the test looks for any errors in <tt>errors.on(:attribute)</tt>.
       # * <tt>strict</tt> - expects the model to raise an exception when the
       #   validation fails rather than adding to the errors collection. Used for
-      #   testing `validates!` and the `:strict => true` validation options.
+      #   testing `validates!` and the `strict: true` validation options.
       #
       # Example:
       #   it { should_not allow_value('bad').for(:isbn) }
@@ -68,7 +68,7 @@ module Shoulda # :nodoc:
 
           values_to_match.none? do |value|
             self.value = value
-            instance.send("#{attribute_to_set}=", value)
+            set_and_double_check_attribute!(attribute_to_set, value)
             errors_match?
           end
         end
@@ -93,6 +93,24 @@ module Shoulda # :nodoc:
           :instance, :attribute_to_set, :attribute_to_check_message_against,
           :context, :value, :matched_error
 
+        def set_and_double_check_attribute!(attribute_name, value)
+          instance.__send__("#{attribute_name}=", value)
+
+          if value.nil?
+            ensure_attribute_was_cleared!(attribute_name)
+          end
+        end
+
+        def ensure_attribute_was_cleared!(attribute_name)
+          if instance.respond_to?(attribute_name)
+            actual_value = instance.__send__(attribute_name)
+
+            if !actual_value.nil?
+              raise Shoulda::Matchers::ActiveModel::CouldNotClearAttribute.create(actual_value)
+            end
+          end
+        end
+
         def errors_match?
           has_messages? && errors_for_attribute_match?
         end
@@ -163,9 +181,9 @@ module Shoulda # :nodoc:
         def default_attribute_message
           default_error_message(
             options[:expected_message],
-            :model_name => model_name,
-            :instance => instance,
-            :attribute => attribute_to_set
+            model_name: model_name,
+            instance: instance,
+            attribute: attribute_to_set
           )
         end
 

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

@@ -35,10 +35,6 @@ module Shoulda # :nodoc:
         end
         alias failure_message_for_should_not failure_message_when_negated
 
-        def allowed_types
-          ''
-        end
-
         def strict
           @allow_matcher.strict
           self

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

@@ -25,6 +25,25 @@ module Shoulda # :nodoc:
         ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
         ARBITRARY_OUTSIDE_FIXNUM = 123456789
         ARBITRARY_OUTSIDE_DECIMAL = 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
+`validates_format_of` in your model, be aware that it is not possible to fully
+test this, and in fact the validation is superfluous, as boolean columns will
+automatically convert non-boolean values to boolean ones. Hence, you should
+consider removing this test and the corresponding validation.
+EOT
+        BOOLEAN_ALLOWS_NIL_MESSAGE = <<EOT
+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)
           super(attribute)
@@ -142,30 +161,63 @@ module Shoulda # :nodoc:
         end
 
         def disallows_value_outside_of_array?
-          disallows_value_of(value_outside_of_array)
+          if attribute_column.type == :boolean
+            case @array
+            when [true, false]
+              Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
+              return true
+            when [nil]
+              if attribute_column.null
+                Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
+                return true
+              else
+                raise NonNullableBooleanError, BOOLEAN_ALLOWS_NIL_WITH_NOT_NULL_MESSAGE
+              end
+            end
+          end
+
+          !allows_value_of(*values_outside_of_array)
         end
 
-        def value_outside_of_array
-          if @array.include?(outside_value)
+        def values_outside_of_array
+          if !(@array & outside_values).empty?
             raise CouldNotDetermineValueOutsideOfArray
           else
-            outside_value
+            outside_values
           end
         end
 
-        def outside_value
-          @outside_value ||= find_outside_value
+        def outside_values
+          case attribute_column.type
+          when :boolean
+            boolean_outside_values
+          when :integer, :float
+            [ARBITRARY_OUTSIDE_FIXNUM]
+          when :decimal
+            [ARBITRARY_OUTSIDE_DECIMAL]
+          else
+            [ARBITRARY_OUTSIDE_STRING]
+          end
         end
 
-        def find_outside_value
-          case @subject.send(@attribute.to_s)
-          when Fixnum
-            ARBITRARY_OUTSIDE_FIXNUM
-          when BigDecimal
-            ARBITRARY_OUTSIDE_DECIMAL 
-          else
-            ARBITRARY_OUTSIDE_STRING
+        def boolean_outside_values
+          values = []
+
+          values << case @array
+            when [true]  then false
+            when [false] then true
+            else              raise CouldNotDetermineValueOutsideOfArray
+          end
+
+          if attribute_column.null
+            values << nil
           end
+
+          values
+        end
+
+        def attribute_column
+          @subject.class.columns_hash[@attribute.to_s]
         end
       end
     end