shoulda-matchers 2.3.0 → 2.4.0.rc1

data/lib/shoulda/matchers.rb

@@ -1,5 +1,6 @@
 require 'shoulda/matchers/version'
 require 'shoulda/matchers/assertion_error'
+require 'shoulda/matchers/rails_shim'
 
 if defined?(RSpec)
   require 'shoulda/matchers/integrations/rspec'

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

@@ -71,7 +71,7 @@ module Shoulda # :nodoc:
 
         def recorded_layouts
           if @context
-            @context.instance_variable_get('@layouts')
+            @context.instance_variable_get(Shoulda::Matchers::RailsShim.layouts_ivar)
           else
             {}
           end

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

@@ -90,20 +90,34 @@ module Shoulda # :nodoc:
         end
 
         def flash
-          if @flash
-            @flash
-          else
-            @flash = @controller.flash.dup
-            used = @controller.flash.instance_variable_get(:@used).dup
-            @flash.instance_variable_set(:@used, used)
-            sweep_flash_if_necessary
-            @flash
+          @flash ||= copy_of_flash_from_controller
+        end
+
+        def copy_of_flash_from_controller
+          @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
+
+        def copy_flashes(original_flash, new_flash)
+          flashes_ivar = Shoulda::Matchers::RailsShim.flashes_ivar
+          flashes = original_flash.instance_variable_get(flashes_ivar).dup
+          new_flash.instance_variable_set(flashes_ivar, flashes)
+        end
+
+        def copy_discard_if_necessary(original_flash, new_flash)
+          discard_ivar = :@discard
+          if original_flash.instance_variable_defined?(discard_ivar)
+            discard = original_flash.instance_variable_get(discard_ivar).dup
+            new_flash.instance_variable_set(discard_ivar, discard)
           end
         end
 
-        def sweep_flash_if_necessary
+        def sweep_flash_if_necessary(flash)
           unless @options[:now]
-            @flash.sweep
+            flash.sweep
           end
         end
 

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

@@ -30,6 +30,7 @@ module Shoulda # :nodoc:
       class AllowValueMatcher # :nodoc:
         include Helpers
 
+        attr_accessor :attribute_with_message
         attr_accessor :options
 
         def initialize(*values)
@@ -39,7 +40,8 @@ module Shoulda # :nodoc:
         end
 
         def for(attribute)
-          self.attribute = attribute
+          self.attribute_to_set = attribute
+          self.attribute_to_check_message_against = attribute
           self
         end
 
@@ -48,8 +50,11 @@ module Shoulda # :nodoc:
           self
         end
 
-        def with_message(message)
+        def with_message(message, options={})
           self.options[:expected_message] = message
+          if options.key?(:against)
+            self.attribute_to_check_message_against = options[:against]
+          end
           self
         end
 
@@ -63,7 +68,7 @@ module Shoulda # :nodoc:
 
           values_to_match.none? do |value|
             self.value = value
-            instance.send("#{attribute}=", value)
+            instance.send("#{attribute_to_set}=", value)
             errors_match?
           end
         end
@@ -83,7 +88,8 @@ module Shoulda # :nodoc:
         private
 
         attr_accessor :values_to_match, :message_finder_factory,
-          :instance, :attribute, :context, :value, :matched_error
+          :instance, :attribute_to_set, :attribute_to_check_message_against,
+          :context, :value, :matched_error
 
         def errors_match?
           has_messages? && errors_for_attribute_match?
@@ -119,7 +125,7 @@ module Shoulda # :nodoc:
 
         def expectation
           includes_expected_message = expected_message ? "to include #{expected_message.inspect}" : ''
-          [error_source, includes_expected_message, "when #{attribute} is set to #{value.inspect}"].join(' ')
+          [error_source, includes_expected_message, "when #{attribute_to_set} is set to #{value.inspect}"].join(' ')
         end
 
         def error_source
@@ -157,7 +163,7 @@ module Shoulda # :nodoc:
             options[:expected_message],
             :model_name => model_name,
             :instance => instance,
-            :attribute => attribute
+            :attribute => attribute_to_set
           )
         end
 
@@ -166,7 +172,7 @@ module Shoulda # :nodoc:
         end
 
         def message_finder
-          message_finder_factory.new(instance, attribute, context)
+          message_finder_factory.new(instance, attribute_to_check_message_against, context)
         end
       end
     end

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

@@ -20,8 +20,8 @@ module Shoulda # :nodoc:
           self
         end
 
-        def with_message(message)
-          @allow_matcher.with_message(message)
+        def with_message(message, options={})
+          @allow_matcher.with_message(message, options)
           self
         end
 

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

@@ -13,9 +13,11 @@ module Shoulda # :nodoc:
       class ValidateConfirmationOfMatcher < ValidationMatcher # :nodoc:
         include Helpers
 
+        attr_reader :attribute, :confirmation_attribute
+
         def initialize(attribute)
           @attribute = attribute
-          @confirmation = "#{attribute}_confirmation"
+          @confirmation_attribute = "#{attribute}_confirmation"
         end
 
         def with_message(message)
@@ -24,7 +26,7 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "require #{@confirmation} to match #{@attribute}"
+          "require #{@confirmation_attribute} to match #{@attribute}"
         end
 
         def matches?(subject)
@@ -40,25 +42,35 @@ module Shoulda # :nodoc:
 
         def disallows_different_value
           set_confirmation('some value')
-          disallows_value_of('different value', @message)
+          disallows_value_of('different value') do |matcher|
+            matcher.with_message(@message, against: error_attribute)
+          end
         end
 
         def allows_same_value
           set_confirmation('same value')
-          allows_value_of('same value', @message)
+          allows_value_of('same value') do |matcher|
+            matcher.with_message(@message, against: error_attribute)
+          end
         end
 
         def allows_missing_confirmation
           set_confirmation(nil)
-          allows_value_of('any value', @message)
+          allows_value_of('any value') do |matcher|
+            matcher.with_message(@message, against: error_attribute)
+          end
         end
 
         def set_confirmation(val)
-          setter = :"#{@confirmation}="
+          setter = :"#{@confirmation_attribute}="
           if @subject.respond_to?(setter)
             @subject.send(setter, val)
           end
         end
+
+        def error_attribute
+          RailsShim.validates_confirmation_of_error_attribute(self)
+        end
       end
     end
   end

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

@@ -30,8 +30,9 @@ module Shoulda # :nodoc:
 
         private
 
-        def allows_value_of(value, message = nil)
+        def allows_value_of(value, message = nil, &block)
           allow = allow_value_matcher(value, message)
+          yield allow if block_given?
 
           if allow.matches?(@subject)
             @failure_message_for_should_not = allow.failure_message_for_should_not
@@ -42,8 +43,9 @@ module Shoulda # :nodoc:
           end
         end
 
-        def disallows_value_of(value, message = nil)
+        def disallows_value_of(value, message = nil, &block)
           disallow = disallow_value_matcher(value, message)
+          yield disallow if block_given?
 
           if disallow.matches?(@subject)
             @failure_message_for_should_not = disallow.failure_message_for_should_not

data/lib/shoulda/matchers/active_record.rb

@@ -4,6 +4,7 @@ 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/association_matchers/option_verifier'
 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

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Shoulda # :nodoc:
   module Matchers
     module ActiveRecord # :nodoc:
@@ -72,6 +74,9 @@ module Shoulda # :nodoc:
       end
 
       class AssociationMatcher # :nodoc:
+        delegate :reflection, :model_class, :associated_class, :through?,
+          :join_table, to: :reflector
+
         def initialize(macro, name)
           @macro = macro
           @name = name
@@ -160,6 +165,14 @@ module Shoulda # :nodoc:
 
         attr_reader :submatchers, :missing, :subject, :macro, :name, :options
 
+        def reflector
+          @reflector ||= AssociationMatchers::ModelReflector.new(subject, name)
+        end
+
+        def option_verifier
+          @option_verifier ||= AssociationMatchers::OptionVerifier.new(reflector)
+        end
+
         def add_submatcher(matcher)
           @submatchers << matcher
         end
@@ -200,10 +213,6 @@ module Shoulda # :nodoc:
           end
         end
 
-        def reflection
-          @reflection ||= model_class.reflect_on_association(name)
-        end
-
         def macro_correct?
           if reflection.macro == macro
             true
@@ -221,27 +230,15 @@ module Shoulda # :nodoc:
           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) &&
             !through? &&
             !class_has_foreign_key?(associated_class)
         end
 
-        def through?
-          reflection.options[:through]
-        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 option_verifier.correct_for_string?(:class_name, options[:class_name])
               true
             else
               @missing = "#{name} should resolve to #{options[:class_name]} for class_name"
@@ -254,7 +251,7 @@ module Shoulda # :nodoc:
 
         def conditions_correct?
           if options.key?(:conditions)
-            if options[:conditions].to_s == reflection.options[:conditions].to_s
+            if option_verifier.correct_for_relation_clause?(:conditions, options[:conditions])
               true
             else
               @missing = "#{name} should have the following conditions: #{options[:conditions]}"
@@ -276,7 +273,7 @@ module Shoulda # :nodoc:
         end
 
         def validate_correct?
-          if option_correct?(:validate)
+          if option_verifier.correct_for_boolean?(:validate, options[:validate])
             true
           else
             @missing = "#{name} should have :validate => #{options[:validate]}"
@@ -285,7 +282,7 @@ module Shoulda # :nodoc:
         end
 
         def touch_correct?
-          if option_correct?(:touch)
+          if option_verifier.correct_for_boolean?(:touch, options[:touch])
             true
           else
             @missing = "#{name} should have :touch => #{options[:touch]}"
@@ -293,17 +290,9 @@ module Shoulda # :nodoc:
           end
         end
 
-        def option_correct?(key)
-          !options.key?(key) || reflection_set_properly_for?(key)
-        end
-
-        def reflection_set_properly_for?(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]
+            option_verifier.correct_for_string?(:foreign_key, options[:foreign_key])
           else
             if klass.column_names.include?(foreign_key)
               true
@@ -314,14 +303,6 @@ module Shoulda # :nodoc:
           end
         end
 
-        def join_table
-          if reflection.respond_to? :join_table
-            reflection.join_table.to_s
-          else
-            reflection.options[:join_table].to_s
-          end
-        end
-
         def foreign_key
           if foreign_key_reflection
             if foreign_key_reflection.respond_to?(:foreign_key)

data/lib/shoulda/matchers/active_record/association_matchers/counter_cache_matcher.rb

@@ -16,9 +16,9 @@ module Shoulda # :nodoc:
           end
 
           def matches?(subject)
-            subject = ModelReflector.new(subject, name)
+            self.subject = ModelReflector.new(subject, name)
 
-            if subject.option_set_properly?(counter_cache, :counter_cache)
+            if option_verifier.correct_for_string?(:counter_cache, counter_cache)
               true
             else
               self.missing_option = "#{name} should have #{description}"
@@ -27,7 +27,12 @@ module Shoulda # :nodoc:
           end
 
           private
-          attr_accessor :counter_cache, :name
+
+          attr_accessor :subject, :counter_cache, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_record/association_matchers/dependent_matcher.rb

@@ -16,9 +16,9 @@ module Shoulda # :nodoc:
           end
 
           def matches?(subject)
-            subject = ModelReflector.new(subject, name)
+            self.subject = ModelReflector.new(subject, name)
 
-            if dependent.nil? || subject.option_set_properly?(dependent, :dependent)
+            if option_verifier.correct_for_string?(:dependent, dependent)
               true
             else
               self.missing_option = "#{name} should have #{dependent} dependency"
@@ -27,7 +27,12 @@ module Shoulda # :nodoc:
           end
 
           private
-          attr_accessor :dependent, :name
+
+          attr_accessor :subject, :dependent, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_record/association_matchers/model_reflector.rb

@@ -20,15 +20,77 @@ module Shoulda # :nodoc:
             subject.class
           end
 
-          def option_string(key)
-            reflection.options[key].to_s
+          def associated_class
+            reflection.klass
           end
 
-          def option_set_properly?(option, option_key)
-            option.to_s == option_string(option_key)
+          def through?
+            reflection.options[:through]
+          end
+
+          def join_table
+            if reflection.respond_to? :join_table
+              reflection.join_table.to_s
+            else
+              reflection.options[:join_table].to_s
+            end
+          end
+
+          def association_relation
+            if reflection.respond_to?(:scope) && reflection.scope
+              relation_from_scope(reflection.scope)
+            else
+              options = reflection.options
+              relation = RailsShim.clean_scope(reflection.klass)
+              if options[:conditions]
+                relation = relation.where(options[:conditions])
+              end
+              if options[:include]
+                relation = relation.include(options[:include])
+              end
+              if options[:order]
+                relation = relation.order(options[:order])
+              end
+              if options[:group]
+                relation = relation.group(options[:group])
+              end
+              if options[:having]
+                relation = relation.having(options[:having])
+              end
+              if options[:limit]
+                relation = relation.limit(options[:limit])
+              end
+              relation
+            end
+          end
+
+          def build_relation_with_clause(name, value)
+            case name
+              when :conditions then associated_class.where(value)
+              when :order      then associated_class.order(value)
+              else                  raise ArgumentError, "Unknown clause '#{name}'"
+            end
+          end
+
+          def extract_relation_clause_from(relation, name)
+            case name
+              when :conditions then relation.where_values_hash
+              when :order      then relation.order_values.join(', ')
+              else                  raise ArgumentError, "Unknown clause '#{name}'"
+            end
           end
 
           private
+
+          def relation_from_scope(scope)
+            # Source: AR::Associations::AssociationScope#eval_scope
+            if scope.is_a?(::Proc)
+              associated_class.all.instance_exec(subject, &scope)
+            else
+              scope
+            end
+          end
+
           attr_reader :subject, :name
         end
       end