mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,46 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module Helpers
+        def pretty_error_messages(obj)
+          obj.errors.map do |attribute, model|
+            msg = "#{attribute} #{model}"
+            if attribute.to_sym != :base && obj.respond_to?(attribute)
+              msg << " (#{obj.__send__(attribute).inspect})"
+            end
+            msg
+          end
+        end
+
+        # Helper method that determines the default error message used by Active
+        # Record.  Works for both existing Rails 2.1 and Rails 2.2 with the newly
+        # introduced I18n module used for localization. Use with Rails 3.0 and
+        # up will delegate to ActiveModel::Errors.generate_error if a model
+        # instance is given.
+        #
+        #   default_error_message(:blank)
+        #   default_error_message(:too_short, count: 5)
+        #   default_error_message(:too_long, count: 60)
+        #   default_error_message(:blank, model_name: 'user', attribute: 'name')
+        #   default_error_message(:blank, instance: #<Model>, attribute: 'name')
+        def default_error_message(key, options = {})
+          model_name = options.delete(:model_name)
+          attribute = options.delete(:attribute)
+          instance = options.delete(:instance)
+
+          if instance && instance.errors.respond_to?(:generate_message)
+            instance.errors.generate_message(attribute.to_sym, key, options)
+          else
+            default_translation = [ :"activerecord.errors.models.#{model_name}.#{key}",
+                                    :"activerecord.errors.messages.#{key}",
+                                    :"errors.attributes.#{attribute}.#{key}",
+                                    :"errors.messages.#{key}" ]
+            I18n.translate(:"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{key}",
+              { default: default_translation }.merge(options))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module NumericalityMatchers
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class ComparisonMatcher < ValidationMatcher
+          def initialize(numericality_matcher, value, operator)
+            unless numericality_matcher.respond_to? :diff_to_compare
+              raise ArgumentError, 'numericality_matcher is invalid'
+            end
+            @numericality_matcher = numericality_matcher
+            @value = value
+            @operator = operator
+            @message = nil
+          end
+
+          def for(attribute)
+            @attribute = attribute
+            self
+          end
+
+          def matches?(subject)
+            @subject = subject
+            all_bounds_correct?
+          end
+
+          def with_message(message)
+            @message = message
+          end
+
+          def comparison_description
+            "#{expectation} #{@value}"
+          end
+
+          private
+
+          def comparison_combos
+            allow = :allows_value_of
+            disallow = :disallows_value_of
+            checker_types =
+              case @operator
+                when :> then [allow, disallow, disallow]
+                when :>= then [allow, allow, disallow]
+                when :== then [disallow, allow, disallow]
+                when :< then [disallow, disallow, allow]
+                when :<= then [disallow, allow, allow]
+              end
+            diffs_to_compare.zip(checker_types)
+          end
+
+          def diffs_to_compare
+            diff = @numericality_matcher.diff_to_compare
+            [diff, 0, -diff]
+          end
+
+          def expectation
+            case @operator
+              when :> then "greater than"
+              when :>= then "greater than or equal to"
+              when :== then "equal to"
+              when :< then "less than"
+              when :<= then "less than or equal to"
+            end
+          end
+
+          def all_bounds_correct?
+            comparison_combos.all? do |diff, checker_type|
+              __send__(checker_type, @value + diff, @message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class EvenNumberMatcher < NumericTypeMatcher
+          NON_EVEN_NUMBER_VALUE = 1
+
+          def initialize(attribute, options = {})
+            @attribute = attribute
+            @disallow_value_matcher = DisallowValueMatcher.new(NON_EVEN_NUMBER_VALUE).
+                for(@attribute).
+                with_message(:even)
+          end
+
+          def allowed_type
+            'even numbers'
+          end
+
+          def diff_to_compare
+            2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class NumericTypeMatcher
+          def initialize
+            raise NotImplementedError
+          end
+
+          def matches?(subject)
+            @disallow_value_matcher.matches?(subject)
+          end
+
+          def with_message(message)
+            @disallow_value_matcher.with_message(message)
+            self
+          end
+
+          def allowed_type
+            raise NotImplementedError
+          end
+
+          def diff_to_compare
+            raise NotImplementedError
+          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/numericality_matchers/odd_number_matcher.rb

@@ -0,0 +1,27 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class OddNumberMatcher < NumericTypeMatcher
+          NON_ODD_NUMBER_VALUE  = 2
+
+          def initialize(attribute, options = {})
+            @attribute = attribute
+            @disallow_value_matcher = DisallowValueMatcher.new(NON_ODD_NUMBER_VALUE).
+                for(@attribute).
+                with_message(:odd)
+          end
+
+          def allowed_type
+            'odd numbers'
+          end
+
+          def diff_to_compare
+            2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class OnlyIntegerMatcher
+          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 allowed_type
+            'integers'
+          end
+
+          def diff_to_compare
+            1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_absence_of` matcher tests the usage of the
+      # `validates_absence_of` validation.
+      #
+      #     class Artillery
+      #       include ActiveModel::Model
+      #
+      #       validates_absence_of :arms
+      #     end
+      #
+      #     # RSpec
+      #     describe Artillery do
+      #       it { should validate_absence_of(:arms) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class ArtilleryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Artillery
+      #       include ActiveModel::Model
+      #
+      #       validates_absence_of :arms, message: "We're fresh outta arms here, soldier!"
+      #     end
+      #
+      #     # RSpec
+      #     describe Artillery do
+      #       it do
+      #         should validate_absence_of(:arms).
+      #           with_message("We're fresh outta arms here, soldier!")
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class ArtilleryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms).
+      #         with_message("We're fresh outta arms here, soldier!")
+      #     end
+      #
+      # @return [ValidateAbsenceOfMatcher}
+      #
+      def validate_absence_of(attr)
+        ValidateAbsenceOfMatcher.new(attr)
+      end
+
+      # @private
+      class ValidateAbsenceOfMatcher < ValidationMatcher
+        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_acceptance_of_matcher.rb

@@ -0,0 +1,77 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_acceptance_of` matcher tests usage of the
+      # `validates_acceptance_of` validation.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #
+      #       validates_acceptance_of :eula
+      #     end
+      #
+      #     # RSpec
+      #     describe Registration do
+      #       it { should validate_acceptance_of(:eula) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:eula)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #
+      #       validates_acceptance_of :terms_of_service,
+      #         message: 'You must accept the terms of service'
+      #     end
+      #
+      #     # RSpec
+      #     describe Registration do
+      #       it do
+      #         should validate_acceptance_of(:terms_of_service).
+      #           with_message('You must accept the terms of service')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms_of_service).
+      #         with_message('You must accept the terms of service')
+      #     end
+      #
+      # @return [ValidateAcceptanceOfMatcher]
+      #
+      def validate_acceptance_of(attr)
+        ValidateAcceptanceOfMatcher.new(attr)
+      end
+
+      # @private
+      class ValidateAcceptanceOfMatcher < ValidationMatcher
+        def with_message(message)
+          if message
+            @expected_message = message
+          end
+          self
+        end
+
+        def matches?(subject)
+          super(subject)
+          @expected_message ||= :accepted
+          disallows_value_of(false, @expected_message)
+        end
+
+        def description
+          "require #{@attribute} to be accepted"
+        end
+      end
+    end
+  end
+end