shoulda-matchers 2.6.0 → 2.6.1.rc1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shoulda-matchers (2.6.0)
+    shoulda-matchers (2.6.1.rc1)
       activesupport (>= 3.0.0)
 
 GEM

data/NEWS.md

@@ -1,3 +1,37 @@
+# HEAD
+
+* Fix `ComparisonMatcher` so that `validate_numericality_of` comparison matchers
+  work with large numbers.
+
+* Fix so that ActiveRecord matchers aren't included when ActiveRecord
+  isn't defined (i.e. if you are using ActiveModel only).
+
+* Revert the behavior of `allow_value` changed in 2.6.0 (it will no longer raise
+  CouldNotClearAttribute). This was originally done as a part of a fix for
+  `validate_presence_of` when used in conjunction with `has_secure_password`.
+  That fix has been updated so that it does not affect `allow_value`.
+
+* Fix callback matchers and correct test coverage.
+
+* Fix `permit` so that it does not interfere with different usages of `params`
+  in your controller action. Specifically, this will not raise an error:
+  `params.fetch(:foo, {}).permit(:bar, :baz)` (the `permit` will have no
+  problems recognizing that :bar and :baz are permitted params).
+
+* Fix `permit` on Rails 4.1 to use PATCH by default for #update instead of PUT.
+  Previously you had to specify this manually.
+
+* Fix `permit` so that it track multiple calls to #permit in your controller
+  action. Previously only the last usage of #permit would be considered in
+  determining whether the matcher matched.
+
+* Fix `permit` so that if the route for your action requires params (such as id)
+  then you can now specify those params:
+  `permit(:first_name, :last_name).for(:update, params: { id: 42 })`.
+
+* Fix `delegate_method` so that it does not stub the target method forever,
+  returning it to its original implementation after the match ends.
+
 # 2.6.0
 
 * The boolean argument to `have_db_index`'s `unique` option is now optional, for

data/README.md

@@ -18,6 +18,20 @@ group :test do
 end
 ```
 
+Note that if you're using a Rails preloader like Spring, you'll need to manually
+require shoulda-matchers in your spec_helper after you require RSpec:
+
+```ruby
+# Gemfile
+group :test do
+  gem 'shoulda-matchers', require: false
+end
+
+# spec_helper
+require 'rspec/rails'
+require 'shoulda/matchers'
+```
+
 ### Test::Unit
 
 shoulda-matchers was originally a component of

data/features/activemodel_integration.feature

@@ -0,0 +1,15 @@
+Feature: integration with ActiveModel
+
+  Scenario: create a new project using matchers
+    When I generate a new ActiveModel application
+    And I configure the application to use "shoulda-matchers" from this project
+    And I write to "load_dependencies.rb" with:
+      """
+      require 'active_model'
+      require 'shoulda-matchers'
+
+      puts ActiveModel::VERSION::STRING
+      puts "Loaded all dependencies without errors"
+      """
+    When I successfully run `bundle exec ruby load_dependencies.rb`
+    Then the output should contain "Loaded all dependencies without errors"

data/features/step_definitions/activemodel_steps.rb

@@ -0,0 +1,21 @@
+When 'I generate a new ActiveModel application' do
+  steps %{
+    When I run `mkdir #{APP_NAME}`
+    And I cd to "#{APP_NAME}"
+    And I run `bundle init`
+  }
+
+  # Figure out the ActiveModel version to use by reusing the Rails version from
+  # the Appraise gemfile.
+  if match = File.read(ENV['BUNDLE_GEMFILE']).match(/^gem "rails", "(.*)"/)
+    append_to_gemfile %(gem 'activemodel', '#{ match[1] }')
+  else
+    puts "Couldn't determine which ActiveModel version to load; using latest"
+    append_to_gemfile %(gem 'activemodel')
+  end
+
+  steps %{
+    And I set the "BUNDLE_GEMFILE" environment variable to "Gemfile"
+    And I install gems
+  }
+end

data/gemfiles/3.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    shoulda-matchers (2.6.0)
+    shoulda-matchers (2.6.1.rc1)
       activesupport (>= 3.0.0)
 
 GEM

data/gemfiles/3.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    shoulda-matchers (2.6.0)
+    shoulda-matchers (2.6.1.rc1)
       activesupport (>= 3.0.0)
 
 GEM

data/gemfiles/3.2.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    shoulda-matchers (2.6.0)
+    shoulda-matchers (2.6.1.rc1)
       activesupport (>= 3.0.0)
 
 GEM

data/gemfiles/4.0.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    shoulda-matchers (2.6.0)
+    shoulda-matchers (2.6.1.rc1)
       activesupport (>= 3.0.0)
 
 GEM

data/gemfiles/4.0.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    shoulda-matchers (2.6.0)
+    shoulda-matchers (2.6.1.rc1)
       activesupport (>= 3.0.0)
 
 GEM

data/gemfiles/4.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .././
   specs:
-    shoulda-matchers (2.6.0)
+    shoulda-matchers (2.6.1.rc1)
       activesupport (>= 3.0.0)
 
 GEM

data/lib/shoulda/matchers.rb

@@ -1,4 +1,5 @@
 require 'shoulda/matchers/assertion_error'
+require 'shoulda/matchers/doublespeak'
 require 'shoulda/matchers/error'
 require 'shoulda/matchers/rails_shim'
 require 'shoulda/matchers/warn'

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

@@ -68,18 +68,20 @@ module Shoulda # :nodoc:
           @callback_type = callback_type
         end
 
-        def matches?(subject)
-          @subject = subject
+        def matches?(controller)
+          @controller = controller
+          @controller_class = controller.class
+
           callbacks.map(&:filter).include?(method_name)
         end
 
         def failure_message
-          "Expected that #{subject.name} would have :#{method_name} as a #{kind}_#{callback_type}"
+          "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 #{subject.name} would not have :#{method_name} as a #{kind}_#{callback_type}"
+          "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
 
@@ -90,10 +92,13 @@ module Shoulda # :nodoc:
         private
 
         def callbacks
-          subject._process_action_callbacks.select { |callback| callback.kind == kind }
+          controller_class._process_action_callbacks.select do |callback|
+            callback.kind == kind
+          end
         end
 
-        attr_reader :method_name, :subject, :kind, :callback_type
+        attr_reader :method_name, :controller, :controller_class, :kind,
+          :callback_type
       end
     end
   end

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

@@ -1,34 +1,34 @@
+require 'delegate'
+
 begin
   require 'strong_parameters'
 rescue LoadError
 end
 
+require 'active_support/hash_with_indifferent_access'
+
 module Shoulda
   module Matchers
     module ActionController
-      def permit(*attributes)
-        StrongParametersMatcher.new(self, attributes)
+      def permit(*params)
+        StrongParametersMatcher.new(params).in_context(self)
       end
 
       class StrongParametersMatcher
-        def self.stubbed_parameters_class
-          @stubbed_parameters_class ||= build_stubbed_parameters_class
-        end
+        attr_writer :stubbed_params
 
-        def self.build_stubbed_parameters_class
-          Class.new(::ActionController::Parameters) do
-            include StubbedParameters
-          end
-        end
-
-        def initialize(context = nil, attributes)
-          @attributes = attributes
-          @context = context
+        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[:verb] || verb_for_action
+          @verb = options.fetch(:verb, default_verb)
+          @request_params = options.fetch(:params, {})
           self
         end
 
@@ -38,128 +38,92 @@ module Shoulda
         end
 
         def description
-          "permit #{verb.upcase} ##{action} to receive parameters #{attributes_as_sentence}"
+          "permit #{verb.upcase} ##{action} to receive parameters #{param_names_as_sentence}"
         end
 
-        def matches?(controller = nil)
-          simulate_controller_action && parameters_difference.empty?
-        end
+        def matches?(controller)
+          @controller = controller
+          ensure_action_and_verb_present!
 
-        def does_not_match?(controller = nil)
-          simulate_controller_action && parameters_intersection.empty?
+          Doublespeak.with_doubles_activated do
+            context.__send__(verb, action, request_params)
+          end
+
+          unpermitted_params.empty?
         end
 
         def failure_message
-          "Expected controller to permit #{parameters_difference.to_sentence}, but it did not."
+          "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 #{parameters_intersection.to_sentence}, but it did."
+          "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 :verb, :action, :attributes, :context
+        attr_reader :controller, :double_collection, :action, :verb,
+          :request_params, :expected_permitted_params, :context
 
-        def simulate_controller_action
-          ensure_action_and_verb_present!
-          stub_model_attributes
-
-          begin
-            context.send(verb, action)
-          ensure
-            unstub_model_attributes
-          end
+        def set_double_collection
+          @double_collection =
+            Doublespeak.register_double_collection(::ActionController::Parameters)
 
-          verify_permit_call
+          @double_collection.register_stub(:require).to_return { |params| params }
+          @double_collection.register_proxy(:permit)
         end
 
-        def verify_permit_call
-          @model_attrs.permit_was_called
+        def actual_permitted_params
+          double_collection.calls_to(:permit).inject([]) do |all_param_names, call|
+            all_param_names + call.args
+          end.flatten
         end
 
-        def parameters_difference
-          attributes - @model_attrs.shoulda_permitted_params
+        def permit_called?
+          actual_permitted_params.any?
         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
+        def unpermitted_params
+          expected_permitted_params - actual_permitted_params
         end
 
-        def unstub_model_attributes
-          ::ActionController::Parameters.class_eval do
-            alias_method :[], :'shoulda_original_[]'
-            undef_method :'shoulda_original_[]'
-          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 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
+        def default_verb
+          case action
+            when :create then :post
+            when :update then RailsShim.verb_for_update
+          end
         end
 
-        def initialize(*)
-          @permit_was_called = false
-          super
+        def param_names_as_sentence
+          expected_permitted_params.map(&:inspect).to_sentence
         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.'
+        class ActionNotDefinedError < StandardError
+          def message
+            'You must specify the controller action using the #for method.'
+          end
         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)'
+        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

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

@@ -37,6 +37,7 @@ module Shoulda # :nodoc:
           self.values_to_match = values
           self.message_finder_factory = ValidationMessageFinder
           self.options = {}
+          self.after_setting_value_callback = -> {}
         end
 
         def for(attribute)
@@ -63,12 +64,16 @@ module Shoulda # :nodoc:
           self
         end
 
+        def _after_setting_value(&callback)  # :nodoc:
+          self.after_setting_value_callback = callback
+        end
+
         def matches?(instance)
           self.instance = instance
 
           values_to_match.none? do |value|
             self.value = value
-            set_and_double_check_attribute!(attribute_to_set, value)
+            set_value(value)
             errors_match?
           end
         end
@@ -91,24 +96,11 @@ module Shoulda # :nodoc:
 
         attr_accessor :values_to_match, :message_finder_factory,
           :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)
+          :context, :value, :matched_error, :after_setting_value_callback
 
-          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
+        def set_value(value)
+          instance.__send__("#{attribute_to_set}=", value)
+          after_setting_value_callback.call
         end
 
         def errors_match?