shoulda-matchers 2.2.0 → 2.3.0

data/.travis.yml

@@ -1,5 +1,8 @@
 script: "bundle exec rake spec cucumber"
 
+install:
+  "bundle install"
+
 rvm:
   - 1.9.2
   - 1.9.3

data/Gemfile.lock

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

data/NEWS.md

@@ -1,5 +1,28 @@
 # HEAD
 
+# v 2.3.0
+
+* Fix a bug in `ensure_inclusion_of` that would cause issues with using
+  `in_array` with an integer value.
+
+* Add support for PostgreSQL UUID columns to `validates_uniqueness_of` (#334).
+
+* Fix `validates_numericality_of` so that `is_equal_to` submatcher works
+  correctly (#326).
+
+* Fix context support for validation matchers and disallowed values (#313).
+
+* Add a `counter_cache` submatcher for `belongs_to` associations (#311).
+
+* Add a `rescue_from` matcher for Rails controllers which checks that the
+  correct ActiveSupport call has been made and that the handlers exist without
+  actually throwing an exception (#287).
+
+* Changed the scope of AssociationMatcher methods from protected to private.
+
+* Extracted `#order`, `#through`, and `#dependent` from AssociationMatcher as
+  their own submatchers.
+
 # v 2.2.0
 
 * Fix `have_and_belong_to_many` matcher issue for Rails 4.
@@ -15,7 +38,8 @@
 * Add missing `failure_message_for_should_not` implementations to
 `validate_numericality_of` and its submatchers
 
-* Support validation contexts for testing validations `on: :create` and when using custom contexts like `model.valid?(:my_context)`.
+* Support validation contexts for testing validations `on: :create` and when
+  using custom contexts like `model.valid?(:my_context)`.
 
 * Fix a bug in validations with autosaved models.
 

data/README.md

@@ -51,8 +51,6 @@ Matchers to test common patterns:
 
 ```ruby
 describe PostsController, "#show" do
-  it { should permit(:title, :body).for(:create) }
-
   context "for a fictional user" do
     before do
       get :show, :id => 1
@@ -61,6 +59,7 @@ describe PostsController, "#show" do
     it { should respond_with(:success) }
     it { should render_template(:show) }
     it { should_not set_the_flash }
+    it { should rescue_from(ActiveRecord::RecordNotFound).with(:render_404) }
   end
 end
 ```

data/gemfiles/3.0.gemfile.lock

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

data/gemfiles/3.1.gemfile.lock

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

data/gemfiles/3.2.gemfile.lock

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

data/lib/shoulda/matchers/action_controller.rb

@@ -6,6 +6,7 @@ require 'shoulda/matchers/action_controller/set_session_matcher'
 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'
 
 module Shoulda
   module Matchers

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

@@ -0,0 +1,81 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      def rescue_from(exception)
+        RescueFromMatcher.new exception
+      end
+
+      class RescueFromMatcher
+        def initialize(exception)
+          @exception = exception
+        end
+
+        def with(method)
+          @expected_method = method
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          rescues_from_exception? && method_name_matches? && handler_exists?
+        end
+
+        def description
+          description = "rescues from #{exception}"
+          description << " with ##{expected_method}" if expected_method
+          description
+        end
+
+        def failure_message_for_should
+          "Expected #{expectation}"
+        end
+
+        def failure_message_for_should_not
+          "Did not expect #{expectation}"
+        end
+
+        private
+
+        attr_reader :controller, :exception, :expected_method, :handlers
+
+        def expectation
+          expectation = "#{controller} to rescue from #{exception}"
+
+          if expected_method && !method_name_matches?
+            expectation << " with ##{expected_method}"
+          end
+
+          unless handler_exists?
+            expectation << " but #{controller} does not respond to #{expected_method}"
+          end
+          expectation
+        end
+
+        def rescues_from_exception?
+          @handlers = controller.rescue_handlers.select do |handler|
+            handler.first == exception.to_s
+          end
+          handlers.any?
+        end
+
+        def method_name_matches?
+          if expected_method.present?
+            handlers.any? do |handler|
+              handler.last == expected_method
+            end
+          else
+            true
+          end
+        end
+
+        def handler_exists?
+          if expected_method.present?
+            controller.respond_to? expected_method
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -31,7 +31,7 @@ module Shoulda # :nodoc:
           case @operator
             when :> then [@value, @value - 1].sample
             when :>= then @value - 1
-            when :== then @value
+            when :== then @value + 1
             when :< then [@value, @value + 1].sample
             when :<= then @value + 1
           end

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

@@ -15,6 +15,11 @@ module Shoulda # :nodoc:
           self
         end
 
+        def on(context)
+          @allow_matcher.on(context)
+          self
+        end
+
         def with_message(message)
           @allow_matcher.with_message(message)
           self

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

@@ -23,6 +23,7 @@ module Shoulda # :nodoc:
 
       class EnsureInclusionOfMatcher < ValidationMatcher # :nodoc:
         ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
+        ARBITRARY_OUTSIDE_FIXNUM = 123456789
 
         def initialize(attribute)
           super(attribute)
@@ -144,8 +145,21 @@ module Shoulda # :nodoc:
         end
 
         def value_outside_of_array
-          if @array.include?(ARBITRARY_OUTSIDE_STRING)
+          if @array.include?(outside_value)
             raise CouldNotDetermineValueOutsideOfArray
+          else
+            outside_value
+          end
+        end
+
+        def outside_value
+          @outside_value ||= find_outside_value
+        end
+
+        def find_outside_value
+          case @subject.send(@attribute.to_s)
+          when Fixnum
+            ARBITRARY_OUTSIDE_FIXNUM
           else
             ARBITRARY_OUTSIDE_STRING
           end

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

@@ -2,7 +2,7 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
 
-      # Ensures that the model cannot be saved the given attribute is not
+      # Ensures that the model cannot be saved if the given attribute is not
       # accepted.
       #
       # Options:

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

@@ -122,7 +122,7 @@ module Shoulda # :nodoc:
         end
 
         def failing_submatchers
-          @failing_submatchers ||= @submatchers.select { |matcher| !matcher.matches?(@subject.dup) }
+          @failing_submatchers ||= @submatchers.select { |matcher| !matcher.matches?(@subject) }
         end
 
         def allowed_types

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

@@ -77,14 +77,6 @@ module Shoulda # :nodoc:
             allows_nil?
         end
 
-        def description
-          result = 'require '
-          result << 'case sensitive ' unless @options[:case_insensitive]
-          result << "unique value for #{@attribute}"
-          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
-          result
-        end
-
         private
 
         def allows_nil?
@@ -197,6 +189,8 @@ module Shoulda # :nodoc:
             '0'
           elsif column.type == :datetime
             DateTime.now
+          elsif column.type == :uuid
+            SecureRandom.uuid
           else
             0
           end

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

@@ -58,6 +58,7 @@ module Shoulda # :nodoc:
           matcher = AllowValueMatcher.
             new(value).
             for(@attribute).
+            on(@context).
             with_message(message)
 
           if strict?
@@ -71,6 +72,7 @@ module Shoulda # :nodoc:
           matcher = DisallowValueMatcher.
             new(value).
             for(@attribute).
+            on(@context).
             with_message(message)
 
           if strict?

data/lib/shoulda/matchers/active_record.rb

@@ -1,4 +1,9 @@
 require 'shoulda/matchers/active_record/association_matcher'
+require 'shoulda/matchers/active_record/association_matchers/counter_cache_matcher'
+require 'shoulda/matchers/active_record/association_matchers/order_matcher'
+require 'shoulda/matchers/active_record/association_matchers/through_matcher'
+require 'shoulda/matchers/active_record/association_matchers/dependent_matcher'
+require 'shoulda/matchers/active_record/association_matchers/model_reflector'
 require 'shoulda/matchers/active_record/have_db_column_matcher'
 require 'shoulda/matchers/active_record/have_db_index_matcher'
 require 'shoulda/matchers/active_record/have_readonly_attribute_matcher'

data/lib/shoulda/matchers/active_record/association_matcher.rb

@@ -76,20 +76,31 @@ module Shoulda # :nodoc:
           @macro = macro
           @name = name
           @options = {}
+          @submatchers = []
+          @missing = ''
         end
 
         def through(through)
-          @options[:through] = through
+          through_matcher = AssociationMatchers::ThroughMatcher.new(through, name)
+          add_submatcher(through_matcher)
           self
         end
 
         def dependent(dependent)
-          @options[:dependent] = dependent
+          dependent_matcher = AssociationMatchers::DependentMatcher.new(dependent, name)
+          add_submatcher(dependent_matcher)
           self
         end
 
         def order(order)
-          @options[:order] = order
+          order_matcher = AssociationMatchers::OrderMatcher.new(order, name)
+          add_submatcher(order_matcher)
+          self
+        end
+
+        def counter_cache(counter_cache = true)
+          counter_cache_matcher = AssociationMatchers::CounterCacheMatcher.new(counter_cache, name)
+          add_submatcher(counter_cache_matcher)
           self
         end
 
@@ -118,51 +129,83 @@ module Shoulda # :nodoc:
           self
         end
 
+        def description
+          description = "#{macro_description} #{name}"
+          description += " class_name => #{options[:class_name]}" if options.key?(:class_name)
+          [description, submatchers.map(&:description)].flatten.join(' ')
+        end
+
+        def failure_message_for_should
+          "Expected #{expectation} (#{missing_options})"
+        end
+
+        def failure_message_for_should_not
+          "Did not expect #{expectation}"
+        end
+
         def matches?(subject)
           @subject = subject
           association_exists? &&
             macro_correct? &&
             foreign_key_exists? &&
-            through_association_valid? &&
-            dependent_correct? &&
             class_name_correct? &&
-            order_correct? &&
             conditions_correct? &&
             join_table_exists? &&
             validate_correct? &&
-            touch_correct?
+            touch_correct? &&
+            submatchers_match?
         end
 
-        def failure_message_for_should
-          "Expected #{expectation} (#{@missing})"
+        private
+
+        attr_reader :submatchers, :missing, :subject, :macro, :name, :options
+
+        def add_submatcher(matcher)
+          @submatchers << matcher
         end
 
-        def failure_message_for_should_not
-          "Did not expect #{expectation}"
+        def macro_description
+          case macro.to_s
+          when 'belongs_to'
+            'belong to'
+          when 'has_many'
+            'have many'
+          when 'has_one'
+            'have one'
+          when 'has_and_belongs_to_many'
+            'have and belong to many'
+          end
         end
 
-        def description
-          description = "#{macro_description} #{@name}"
-          description += " through #{@options[:through]}"          if @options.key?(:through)
-          description += " dependent => #{@options[:dependent]}"   if @options.key?(:dependent)
-          description += " class_name => #{@options[:class_name]}" if @options.key?(:class_name)
-          description += " order => #{@options[:order]}"           if @options.key?(:order)
-          description
+        def expectation
+          "#{model_class.name} to have a #{macro} association called #{name}"
+        end
+
+        def missing_options
+          [missing, failing_submatchers.map(&:missing_option)].flatten.join
         end
 
-        protected
+        def failing_submatchers
+          @failing_submatchers ||= submatchers.select do |matcher|
+            !matcher.matches?(subject)
+          end
+        end
 
         def association_exists?
           if reflection.nil?
-            @missing = "no association called #{@name}"
+            @missing = "no association called #{name}"
             false
           else
             true
           end
         end
 
+        def reflection
+          @reflection ||= model_class.reflect_on_association(name)
+        end
+
         def macro_correct?
-          if reflection.macro == @macro
+          if reflection.macro == macro
             true
           else
             @missing = "actual association type was #{reflection.macro}"
@@ -175,66 +218,33 @@ module Shoulda # :nodoc:
         end
 
         def belongs_foreign_key_missing?
-          @macro == :belongs_to && !class_has_foreign_key?(model_class)
+          macro == :belongs_to && !class_has_foreign_key?(model_class)
+        end
+
+        def model_class
+          subject.class
         end
 
         def has_foreign_key_missing?
-          [:has_many, :has_one].include?(@macro) &&
+          [:has_many, :has_one].include?(macro) &&
             !through? &&
             !class_has_foreign_key?(associated_class)
         end
 
-        def through_association_valid?
-          @options[:through].nil? || (through_association_exists? && through_association_correct?)
-        end
-
-        def through_association_exists?
-          if through_reflection.nil?
-            @missing = "#{model_class.name} does not have any relationship to #{@options[:through]}"
-            false
-          else
-            true
-          end
-        end
-
-        def through_association_correct?
-          if @options[:through] == reflection.options[:through]
-            true
-          else
-            @missing = "Expected #{model_class.name} to have #{@name} through #{@options[:through]}, " +
-              "but got it through #{reflection.options[:through]}"
-            false
-          end
+        def through?
+          reflection.options[:through]
         end
 
-        def dependent_correct?
-          if @options[:dependent].nil? || @options[:dependent].to_s == reflection.options[:dependent].to_s
-            true
-          else
-            @missing = "#{@name} should have #{@options[:dependent]} dependency"
-            false
-          end
+        def associated_class
+          reflection.klass
         end
 
         def class_name_correct?
-          if @options.key?(:class_name)
-            if @options[:class_name].to_s == reflection.klass.to_s
+          if options.key?(:class_name)
+            if options[:class_name].to_s == reflection.klass.to_s
               true
             else
-              @missing = "#{@name} should resolve to #{@options[:class_name]} for class_name"
-              false
-            end
-          else
-            true
-          end
-        end
-
-        def order_correct?
-          if @options.key?(:order)
-            if @options[:order].to_s == reflection.options[:order].to_s
-              true
-            else
-              @missing = "#{@name} should be ordered by #{@options[:order]}"
+              @missing = "#{name} should resolve to #{options[:class_name]} for class_name"
               false
             end
           else
@@ -243,11 +253,11 @@ module Shoulda # :nodoc:
         end
 
         def conditions_correct?
-          if @options.key?(:conditions)
-            if @options[:conditions].to_s == reflection.options[:conditions].to_s
+          if options.key?(:conditions)
+            if options[:conditions].to_s == reflection.options[:conditions].to_s
               true
             else
-              @missing = "#{@name} should have the following conditions: #{@options[:conditions]}"
+              @missing = "#{name} should have the following conditions: #{options[:conditions]}"
               false
             end
           else
@@ -256,7 +266,7 @@ module Shoulda # :nodoc:
         end
 
         def join_table_exists?
-          if @macro != :has_and_belongs_to_many ||
+          if macro != :has_and_belongs_to_many ||
               model_class.connection.tables.include?(join_table)
             true
           else
@@ -269,7 +279,7 @@ module Shoulda # :nodoc:
           if option_correct?(:validate)
             true
           else
-            @missing = "#{@name} should have :validate => #{@options[:validate]}"
+            @missing = "#{name} should have :validate => #{options[:validate]}"
             false
           end
         end
@@ -278,22 +288,22 @@ module Shoulda # :nodoc:
           if option_correct?(:touch)
             true
           else
-            @missing = "#{@name} should have :touch => #{@options[:touch]}"
+            @missing = "#{name} should have :touch => #{options[:touch]}"
             false
           end
         end
 
         def option_correct?(key)
-          !@options.key?(key) || reflection_set_properly_for?(key)
+          !options.key?(key) || reflection_set_properly_for?(key)
         end
 
         def reflection_set_properly_for?(key)
-          @options[key] == !!reflection.options[key]
+          options[key] == !!reflection.options[key]
         end
 
         def class_has_foreign_key?(klass)
-          if @options.key?(:foreign_key)
-            reflection.options[:foreign_key] == @options[:foreign_key]
+          if options.key?(:foreign_key)
+            reflection.options[:foreign_key] == options[:foreign_key]
           else
             if klass.column_names.include?(foreign_key)
               true
@@ -304,10 +314,6 @@ module Shoulda # :nodoc:
           end
         end
 
-        def model_class
-          @subject.class
-        end
-
         def join_table
           if reflection.respond_to? :join_table
             reflection.join_table.to_s
@@ -316,10 +322,6 @@ module Shoulda # :nodoc:
           end
         end
 
-        def associated_class
-          reflection.klass
-        end
-
         def foreign_key
           if foreign_key_reflection
             if foreign_key_reflection.respond_to?(:foreign_key)
@@ -330,41 +332,16 @@ module Shoulda # :nodoc:
           end
         end
 
-        def through?
-          reflection.options[:through]
-        end
-
-        def reflection
-          @reflection ||= model_class.reflect_on_association(@name)
-        end
-
         def foreign_key_reflection
-          if [:has_one, :has_many].include?(@macro) && reflection.options.include?(:inverse_of)
+          if [:has_one, :has_many].include?(macro) && reflection.options.include?(:inverse_of)
             associated_class.reflect_on_association(reflection.options[:inverse_of])
           else
             reflection
           end
         end
 
-        def through_reflection
-          @through_reflection ||= model_class.reflect_on_association(@options[:through])
-        end
-
-        def expectation
-          "#{model_class.name} to have a #{@macro} association called #{@name}"
-        end
-
-        def macro_description
-          case @macro.to_s
-          when 'belongs_to'
-            'belong to'
-          when 'has_many'
-            'have many'
-          when 'has_one'
-            'have one'
-          when 'has_and_belongs_to_many'
-            'have and belong to many'
-          end
+        def submatchers_match?
+          failing_submatchers.empty?
         end
       end
     end