mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,121 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_confirmation_of` matcher tests usage of the
+      # `validates_confirmation_of` validation.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_confirmation_of :email
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should validate_confirmation_of(:email) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:email)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_confirmation_of :password,
+      #         message: 'Please re-enter your password'
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it do
+      #         should validate_confirmation_of(:password).
+      #           with_message('Please re-enter your password')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password).
+      #         with_message('Please re-enter your password')
+      #     end
+      #
+      # @return [ValidateConfirmationOfMatcher]
+      #
+      def validate_confirmation_of(attr)
+        ValidateConfirmationOfMatcher.new(attr)
+      end
+
+      # @private
+      class ValidateConfirmationOfMatcher < ValidationMatcher
+        include Helpers
+
+        attr_reader :attribute, :confirmation_attribute
+
+        def initialize(attribute)
+          @attribute = attribute
+          @confirmation_attribute = "#{attribute}_confirmation"
+        end
+
+        def with_message(message)
+          @message = message if message
+          self
+        end
+
+        def description
+          "require #{@confirmation_attribute} to match #{@attribute}"
+        end
+
+        def matches?(subject)
+          super(subject)
+          @message ||= :confirmation
+
+          disallows_different_value &&
+            allows_same_value &&
+            allows_missing_confirmation
+        end
+
+        private
+
+        def disallows_different_value
+          set_confirmation('some value')
+          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') do |matcher|
+            matcher.with_message(@message, against: error_attribute)
+          end
+        end
+
+        def allows_missing_confirmation
+          set_confirmation(nil)
+          allows_value_of('any value') do |matcher|
+            matcher.with_message(@message, against: error_attribute)
+          end
+        end
+
+        def set_confirmation(val)
+          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
+end

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

@@ -0,0 +1,380 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_numericality_of` matcher tests usage of the
+      # `validates_numericality_of` validation.
+      #
+      #     class Person < ActiveRecord::Base
+      #       validates_numericality_of :gpa
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:gpa) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:gpa)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### only_integer
+      #
+      # Use `only_integer` to test usage of the `:only_integer` option. This
+      # asserts that your attribute only allows integer numbers and disallows
+      # non-integer ones.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :age, only_integer: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:age).only_integer }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:age).only_integer
+      #     end
+      #
+      # ##### is_less_than
+      #
+      # Use `is_less_than` to test usage of the the `:less_than` option. This
+      # asserts that the attribute can take a number which is less than the
+      # given value and cannot take a number which is greater than or equal to
+      # it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :number_of_cars, less_than: 2
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:number_of_cars).is_less_than(2) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:number_of_cars).is_less_than(2)
+      #     end
+      #
+      # ##### is_less_than_or_equal_to
+      #
+      # Use `is_less_than_or_equal_to` to test usage of the
+      # `:less_than_or_equal_to` option. This asserts that the attribute can
+      # take a number which is less than or equal to the given value and cannot
+      # take a number which is greater than it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :birth_year, less_than_or_equal_to: 1987
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:birth_year).is_less_than_or_equal_to(1987) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:birth_year).is_less_than_or_equal_to(1987)
+      #     end
+      #
+      # ##### is_equal_to
+      #
+      # Use `is_equal_to` to test usage of the `:equal_to` option. This asserts
+      # that the attribute can take a number which is equal to the given value
+      # and cannot take a number which is not equal.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :weight, equal_to: 150
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:weight).is_equal_to(150) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:weight).is_equal_to(150)
+      #     end
+      #
+      # ##### is_greater_than_or_equal_to
+      #
+      # Use `is_greater_than_or_equal_to` to test usage of the
+      # `:greater_than_or_equal_to` option. This asserts that the attribute can
+      # take a number which is greater than or equal to the given value and
+      # cannot take a number which is less than it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :height, greater_than_or_equal_to: 55
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:height).is_greater_than_or_equal_to(55) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:height).is_greater_than_or_equal_to(55)
+      #     end
+      #
+      # ##### is_greater_than
+      #
+      # Use `is_greater_than` to test usage of tthe `:greater_than` option.
+      # This asserts that the attribute can take a number which is greater than
+      # the given value and cannot take a number less than or equal to it.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :legal_age, greater_than: 21
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:legal_age).is_greater_than(21) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:legal_age).is_greater_than(21)
+      #     end
+      #
+      # ##### even
+      #
+      # Use `even` to test usage of the `:even` option. This asserts that the
+      # attribute can take odd numbers and cannot take even ones.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :birth_month, even: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:birth_month).even }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:birth_month).even
+      #     end
+      #
+      # ##### odd
+      #
+      # Use `odd` to test usage of the `:odd` option. This asserts that the
+      # attribute can take a number which is odd and cannot take a number which
+      # is even.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :birth_day, odd: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:birth_day).odd }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:birth_day).odd
+      #     end
+      #
+      # ##### allow_nil
+      #
+      # Use `allow_nil` to assert that the attribute allows nil.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validate_numericality_of :rank, allow_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it { should validate_numericality_of(:rank).allow_nil }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_uniqueness_of(:rank).allow_nil
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validates_numericality_of :number_of_dependents,
+      #         message: 'Number of dependents must be a number'
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should validate_numericality_of(:number_of_dependents).
+      #           with_message('Number of dependents must be a number')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:number_of_dependents).
+      #         with_message('Number of dependents must be a number')
+      #     end
+      #
+      # @return [ValidateNumericalityOfMatcher]
+      #
+      def validate_numericality_of(attr)
+        ValidateNumericalityOfMatcher.new(attr)
+      end
+
+      # @private
+      class ValidateNumericalityOfMatcher
+        NUMERIC_NAME = 'numbers'
+        NON_NUMERIC_VALUE = 'abcd'
+
+        def initialize(attribute)
+          @attribute = attribute
+          @submatchers = []
+
+          add_disallow_value_matcher
+        end
+
+        def only_integer
+          add_submatcher(NumericalityMatchers::OnlyIntegerMatcher.new(@attribute))
+          self
+        end
+
+        def is_greater_than(value)
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>).for(@attribute))
+          self
+        end
+
+        def is_greater_than_or_equal_to(value)
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>=).for(@attribute))
+          self
+        end
+
+        def is_equal_to(value)
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :==).for(@attribute))
+          self
+        end
+
+        def is_less_than(value)
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<).for(@attribute))
+          self
+        end
+
+        def is_less_than_or_equal_to(value)
+          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<=).for(@attribute))
+          self
+        end
+
+        def odd
+          odd_number_matcher = NumericalityMatchers::OddNumberMatcher.new(@attribute)
+          add_submatcher(odd_number_matcher)
+          self
+        end
+
+        def even
+          even_number_matcher = NumericalityMatchers::EvenNumberMatcher.new(@attribute)
+          add_submatcher(even_number_matcher)
+          self
+        end
+
+        def with_message(message)
+          @submatchers.each { |matcher| matcher.with_message(message) }
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+          submatchers_match?
+        end
+
+        def description
+          "only allow #{allowed_types} for #{@attribute}#{comparison_descriptions}"
+        end
+
+        def failure_message
+          submatcher_failure_messages_for_should.last
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          submatcher_failure_messages_for_should_not.last
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        private
+
+        def add_disallow_value_matcher
+          disallow_value_matcher = DisallowValueMatcher.new(NON_NUMERIC_VALUE).
+            for(@attribute).
+            with_message(:not_a_number)
+
+          add_submatcher(disallow_value_matcher)
+        end
+
+        def add_submatcher(submatcher)
+          @submatchers << submatcher
+        end
+
+        def submatchers_match?
+          failing_submatchers.empty?
+        end
+
+        def submatcher_failure_messages_for_should
+          failing_submatchers.map(&:failure_message)
+        end
+
+        def submatcher_failure_messages_for_should_not
+          failing_submatchers.map(&:failure_message_when_negated)
+        end
+
+        def failing_submatchers
+          @failing_submatchers ||= @submatchers.select { |matcher| !matcher.matches?(@subject) }
+        end
+
+        def allowed_types
+          allowed_array = submatcher_allowed_types
+          allowed_array.empty? ? NUMERIC_NAME : allowed_array.join(', ')
+        end
+
+        def submatcher_allowed_types
+          @submatchers.inject([]){|m, s| m << s.allowed_type if s.respond_to?(:allowed_type); m }
+        end
+
+        def comparison_descriptions
+          description_array = submatcher_comparison_descriptions
+          description_array.empty? ? '' : ' which are ' + submatcher_comparison_descriptions.join(' and ')
+        end
+
+        def submatcher_comparison_descriptions
+          @submatchers.inject([]){|m, s| m << s.comparison_description if s.respond_to?(:comparison_description); m }
+        end
+      end
+    end
+  end
+end