shoulda-matchers 2.4.0 → 2.5.0

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

@@ -0,0 +1,41 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      module NumericalityMatchers
+        class OnlyIntegerMatcher # :nodoc:
+          NON_INTEGER_VALUE = 0.1
+
+          def initialize(attribute)
+            @attribute = attribute
+            @disallow_value_matcher = DisallowValueMatcher.new(NON_INTEGER_VALUE).
+              for(attribute).
+              with_message(:not_an_integer)
+          end
+
+          def matches?(subject)
+            @disallow_value_matcher.matches?(subject)
+          end
+
+          def with_message(message)
+            @disallow_value_matcher.with_message(message)
+            self
+          end
+
+          def allowed_types
+            'integer'
+          end
+
+          def failure_message
+            @disallow_value_matcher.failure_message
+          end
+          alias failure_message_for_should failure_message
+
+          def failure_message_when_negated
+            @disallow_value_matcher.failure_message_when_negated
+          end
+          alias failure_message_for_should_not failure_message_when_negated
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # Ensures that the model is not valid if the given attribute is present.
+      #
+      # Options:
+      # * <tt>with_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
+      #   Defaults to the translation for <tt>:present</tt>.
+      #
+      # Examples:
+      #   it { should validate_absence_of(:name) }
+      #   it { should validate_absence_of(:name).
+      #                 with_message(/may not be set/) }
+      def validate_absence_of(attr)
+        ValidateAbsenceOfMatcher.new(attr)
+      end
+
+      class ValidateAbsenceOfMatcher < ValidationMatcher # :nodoc:
+
+        def with_message(message)
+          @expected_message = message
+          self
+        end
+
+        def matches?(subject)
+          super(subject)
+          @expected_message ||= :present
+          disallows_value_of(value, @expected_message)
+        end
+
+        def description
+          "require #{@attribute} to not be set"
+        end
+
+        private
+
+        def value
+          if reflection
+            obj = reflection.klass.new
+            if collection?
+              [ obj ]
+            else
+              obj
+            end
+          elsif attribute_class == Fixnum
+            1
+          elsif !attribute_class || attribute_class == String
+            'an arbitrary value'
+          else
+            attribute_class.new
+          end
+        end
+
+        def attribute_class
+          @subject.class.respond_to?(:columns_hash) &&
+            @subject.class.columns_hash[@attribute].respond_to?(:klass) &&
+            @subject.class.columns_hash[@attribute].klass
+        end
+
+        def collection?
+          if reflection
+            [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
+          else
+            false
+          end
+        end
+
+        def reflection
+          @subject.class.respond_to?(:reflect_on_association) &&
+            @subject.class.reflect_on_association(@attribute)
+        end
+      end
+    end
+  end
+end

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

@@ -32,43 +32,43 @@ module Shoulda # :nodoc:
         end
 
         def only_integer
-          add_submatcher(OnlyIntegerMatcher.new(@attribute))
+          add_submatcher(NumericalityMatchers::OnlyIntegerMatcher.new(@attribute))
           self
         end
 
         def is_greater_than(value)
-          add_submatcher(ComparisonMatcher.new(value, :>).for(@attribute))
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>).for(@attribute))
           self
         end
 
         def is_greater_than_or_equal_to(value)
-          add_submatcher(ComparisonMatcher.new(value, :>=).for(@attribute))
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>=).for(@attribute))
           self
         end
 
         def is_equal_to(value)
-          add_submatcher(ComparisonMatcher.new(value, :==).for(@attribute))
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :==).for(@attribute))
           self
         end
 
         def is_less_than(value)
-          add_submatcher(ComparisonMatcher.new(value, :<).for(@attribute))
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<).for(@attribute))
           self
         end
 
         def is_less_than_or_equal_to(value)
-          add_submatcher(ComparisonMatcher.new(value, :<=).for(@attribute))
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<=).for(@attribute))
           self
         end
 
         def odd
-          odd_number_matcher = OddEvenNumberMatcher.new(@attribute, :odd => true)
+          odd_number_matcher = NumericalityMatchers::OddEvenNumberMatcher.new(@attribute, :odd => true)
           add_submatcher(odd_number_matcher)
           self
         end
 
         def even
-          even_number_matcher = OddEvenNumberMatcher.new(@attribute, :even => true)
+          even_number_matcher = NumericalityMatchers::OddEvenNumberMatcher.new(@attribute, :even => true)
           add_submatcher(even_number_matcher)
           self
         end
@@ -87,13 +87,15 @@ module Shoulda # :nodoc:
           "only allow #{allowed_types} values for #{@attribute}"
         end
 
-        def failure_message_for_should
+        def failure_message
           submatcher_failure_messages_for_should.last
         end
+        alias failure_message_for_should failure_message
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           submatcher_failure_messages_for_should_not.last
         end
+        alias failure_message_for_should_not failure_message_when_negated
 
         private
 
@@ -114,11 +116,11 @@ module Shoulda # :nodoc:
         end
 
         def submatcher_failure_messages_for_should
-          failing_submatchers.map(&:failure_message_for_should)
+          failing_submatchers.map(&:failure_message)
         end
 
         def submatcher_failure_messages_for_should_not
-          failing_submatchers.map(&:failure_message_for_should_not)
+          failing_submatchers.map(&:failure_message_when_negated)
         end
 
         def failing_submatchers

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

@@ -3,7 +3,7 @@ module Shoulda # :nodoc:
     module ActiveModel # :nodoc:
       # Ensures that the model is invalid if the given attribute is not unique.
       # It uses the first existing record or creates a new one if no record
-      # exists in the database. It simply uses `:validate => false` to get
+      # exists in the database. It simply uses `validate: false` to get
       # around validations, so it will probably fail if there are `NOT NULL`
       # constraints. In that case, you must create a record before calling
       # `validate_uniqueness_of`.
@@ -110,12 +110,12 @@ module Shoulda # :nodoc:
           if options[:nil_value]
             value = nil
           else
-            value = "arbitrary_string"
+            value = 'a'
           end
 
           @subject.class.new.tap do |instance|
             instance.send("#{@attribute}=", value)
-            instance.save(:validate => false)
+            instance.save(validate: false)
           end
         end
 
@@ -127,7 +127,7 @@ module Shoulda # :nodoc:
                 @subject.send(setter, existing_record.send(scope))
                 true
               else
-                @failure_message_for_should = "#{class_name} doesn't seem to have a #{scope} attribute."
+                @failure_message = "#{class_name} doesn't seem to have a #{scope} attribute."
                 false
               end
             end
@@ -173,11 +173,11 @@ module Shoulda # :nodoc:
               if allows_value_of(existing_value, @expected_message)
                 @subject.send("#{scope}=", previous_value)
 
-                @failure_message_for_should_not <<
+                @failure_message_when_negated <<
                   " (with different value of #{scope})"
                 true
               else
-                @failure_message_for_should << " (with different value of #{scope})"
+                @failure_message << " (with different value of #{scope})"
                 false
               end
             end

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

@@ -2,7 +2,9 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
       class ValidationMatcher # :nodoc:
-        attr_reader :failure_message_for_should
+        attr_reader :failure_message
+
+        alias failure_message_for_should failure_message
 
         def initialize(attribute)
           @attribute = attribute
@@ -19,9 +21,10 @@ module Shoulda # :nodoc:
           self
         end
 
-        def failure_message_for_should_not
-          @failure_message_for_should_not || @failure_message_for_should
+        def failure_message_when_negated
+          @failure_message_when_negated || @failure_message
         end
+        alias failure_message_for_should_not failure_message_when_negated
 
         def matches?(subject)
           @subject = subject
@@ -35,10 +38,10 @@ module Shoulda # :nodoc:
           yield allow if block_given?
 
           if allow.matches?(@subject)
-            @failure_message_for_should_not = allow.failure_message_for_should_not
+            @failure_message_when_negated = allow.failure_message_when_negated
             true
           else
-            @failure_message_for_should = allow.failure_message_for_should
+            @failure_message = allow.failure_message
             false
           end
         end
@@ -48,10 +51,10 @@ module Shoulda # :nodoc:
           yield disallow if block_given?
 
           if disallow.matches?(@subject)
-            @failure_message_for_should_not = disallow.failure_message_for_should_not
+            @failure_message_when_negated = disallow.failure_message_when_negated
             true
           else
-            @failure_message_for_should = disallow.failure_message_for_should
+            @failure_message = disallow.failure_message
             false
           end
         end

data/lib/shoulda/matchers/active_record.rb

@@ -3,7 +3,9 @@ require 'shoulda/matchers/active_record/association_matchers/counter_cache_match
 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/source_matcher'
 require 'shoulda/matchers/active_record/association_matchers/model_reflector'
+require 'shoulda/matchers/active_record/association_matchers/model_reflection'
 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'

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

@@ -50,13 +50,15 @@ module Shoulda
             update_only_correct?
         end
 
-        def failure_message_for_should
+        def failure_message
           "Expected #{expectation} (#{@problem})"
         end
+        alias failure_message_for_should failure_message
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "Did not expect #{expectation}"
         end
+        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           description = "accepts_nested_attributes_for :#{@name}"

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

@@ -1,4 +1,4 @@
-require 'forwardable'
+require 'active_support/core_ext/module/delegation'
 
 module Shoulda # :nodoc:
   module Matchers
@@ -109,6 +109,12 @@ module Shoulda # :nodoc:
           self
         end
 
+        def source(source)
+          source_matcher = AssociationMatchers::SourceMatcher.new(source, name)
+          add_submatcher(source_matcher)
+          self
+        end
+
         def conditions(conditions)
           @options[:conditions] = conditions
           self
@@ -140,13 +146,15 @@ module Shoulda # :nodoc:
           [description, submatchers.map(&:description)].flatten.join(' ')
         end
 
-        def failure_message_for_should
+        def failure_message
           "Expected #{expectation} (#{missing_options})"
         end
+        alias failure_message_for_should failure_message
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "Did not expect #{expectation}"
         end
+        alias failure_message_for_should_not failure_message_when_negated
 
         def matches?(subject)
           @subject = subject

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

@@ -0,0 +1,80 @@
+require 'delegate'
+
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        class ModelReflection < SimpleDelegator
+          def initialize(reflection)
+            super(reflection)
+            @reflection = reflection
+            @subject = reflection.active_record
+          end
+
+          def associated_class
+            reflection.klass
+          end
+
+          def through?
+            reflection.options[:through]
+          end
+
+          def join_table
+            join_table =
+              if reflection.respond_to?(:join_table)
+                reflection.join_table
+              else
+                reflection.options[:join_table]
+              end
+
+            join_table.to_s
+          end
+
+          def association_relation
+            if reflection.respond_to?(:scope)
+              convert_scope_to_relation(reflection.scope)
+            else
+              convert_options_to_relation(reflection.options)
+            end
+          end
+
+          private
+
+          attr_reader :reflection, :subject
+
+          def convert_scope_to_relation(scope)
+            relation = associated_class.all
+
+            if scope
+              # Source: AR::Associations::AssociationScope#eval_scope
+              relation.instance_exec(subject, &scope)
+            else
+              relation
+            end
+          end
+
+          def convert_options_to_relation(options)
+            relation = associated_class.scoped
+            relation = extend_relation_with(relation, :where, options[:conditions])
+            relation = extend_relation_with(relation, :includes, options[:include])
+            relation = extend_relation_with(relation, :order, options[:order])
+            relation = extend_relation_with(relation, :group, options[:group])
+            relation = extend_relation_with(relation, :having, options[:having])
+            relation = extend_relation_with(relation, :limit, options[:limit])
+            relation = extend_relation_with(relation, :offset, options[:offset])
+            relation = extend_relation_with(relation, :select, options[:select])
+            relation
+          end
+
+          def extend_relation_with(relation, method_name, value)
+            if value
+              relation.__send__(method_name, value)
+            else
+              relation
+            end
+          end
+        end
+      end
+    end
+  end
+end