mongoid-spec 4.0.1

data/lib/matchers/validations/exclusion_of.rb

@@ -0,0 +1,49 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateExclusionOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :exclusion)
+        end
+
+        def to_not_allow(*values)
+          @not_allowed_values = [values].flatten
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          if @not_allowed_values
+            raw_validator_not_allowed_values = @validator.options[:in]
+
+            validator_not_allowed_values = case raw_validator_not_allowed_values
+            when Range then raw_validator_not_allowed_values.to_a
+            when Proc then raw_validator_not_allowed_values.call(actual)
+            else raw_validator_not_allowed_values end
+
+            allowed_values = @not_allowed_values - validator_not_allowed_values
+            if allowed_values.empty?
+              @positive_result_message = @positive_result_message << " not allowing all values mentioned"
+            else
+              @negative_result_message = @negative_result_message << " allowing the following the ff. values: #{allowed_values.inspect}"
+              result = false
+            end
+          end
+
+          result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " not allowing the ff. values: #{@not_allowed_values}" if @not_allowed_values
+          super << options_desc.to_sentence
+        end
+      end
+
+      def validate_exclusion_of(field)
+        ValidateExclusionOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/format_of.rb

@@ -0,0 +1,71 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateFormatOfMatcher < HaveValidationMatcher
+        def initialize(field)
+          super(field, :format)
+        end
+
+        def with_format(format)
+          @format = format
+          self
+        end
+
+        def to_allow(valid_value)
+          @valid_value = valid_value
+          self
+        end
+
+        def not_to_allow(invalid_value)
+          @invalid_value = invalid_value
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          if @format
+            if @validator.options[:with] == @format
+              @positive_result_message = @positive_result_message << " with format #{@validator.options[:format].inspect}"
+            else
+              @negative_result_message = @negative_result_message << " with format #{@validator.options[:format].inspect}"
+              result = false
+            end
+          end
+
+          if @valid_value
+            if @validator.options[:with] =~ @valid_value
+              @positive_result_message = @positive_result_message << " with #{@valid_value.inspect} as a valid value"
+            else
+              @negative_result_message = @negative_result_message << " with #{@valid_value.inspect} as an invalid value"
+              result = false
+            end
+          end
+
+          if @invalid_value
+            if !(@invalid_value =~ @validator.options[:with])
+              @positive_result_message = @positive_result_message << " with #{@invalid_value.inspect} as an invalid value"
+            else
+              @negative_result_message = @negative_result_message << " with #{@invalid_value.inspect} as a valid value"
+              result = false
+            end
+          end
+
+          result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " with format #{@format.inspect}" if @format
+          options_desc << " allowing the value #{@valid_value.inspect}" if @valid_value
+          options_desc << " not allowing the value #{@invalid_value.inspect}" if @invalid_value
+          super << options_desc.to_sentence
+        end
+      end
+
+      def validate_format_of(field)
+        ValidateFormatOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/inclusion_of.rb

@@ -0,0 +1,49 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateInclusionOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :inclusion)
+        end
+
+        def to_allow(*values)
+          @allowed_values = values.map { |v| v.respond_to?(:to_a) ? v.to_a : v }.flatten
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          if @allowed_values
+            raw_validator_allowed_values = @validator.options[:in]
+
+            validator_allowed_values = case raw_validator_allowed_values
+            when Range then raw_validator_allowed_values.to_a
+            when Proc then raw_validator_allowed_values.call(actual)
+            else raw_validator_allowed_values end
+
+            not_allowed_values = @allowed_values - validator_allowed_values
+            if not_allowed_values.empty?
+              @positive_result_message = @positive_result_message << " allowing all values mentioned"
+            else
+              @negative_result_message = @negative_result_message << " not allowing these values: #{not_allowed_values.inspect}"
+              result = false
+            end
+          end
+
+          result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " allowing these values: #{@allowed_values}" if @allowed_values
+          super << options_desc.to_sentence
+        end
+      end
+
+      def validate_inclusion_of(field)
+        ValidateInclusionOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/length_of.rb

@@ -0,0 +1,147 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateLengthOfMatcher < HaveValidationMatcher
+        include WithMessage
+
+        def initialize(name)
+          super(name, :length)
+        end
+
+        def with_maximum(value)
+          @maximum = value
+          self
+        end
+        alias :less_than :with_maximum
+
+        def with_minimum(value)
+          @minimum = value
+          self
+        end
+        alias :greater_than :with_minimum
+
+        def within(value)
+          @within = value
+          self
+        end
+        alias :in :within
+
+        def as_exactly(value)
+          @is = value
+          self
+        end
+        alias :is :as_exactly
+
+        def with_message(message)
+          @expected_message = message
+          self
+        end
+
+        def matches?(actual)
+          return false unless @result = super(actual)
+
+          check_maximum if @maximum
+          check_minimum if @minimum
+          check_range if @within
+          check_exact if @is
+          check_expected_message if @expected_message
+
+          @result
+        end
+
+        def description
+          options_desc = []
+          options_desc << "with minimum of #{@minimum}" if @minimum
+          options_desc << "with maximum of #{@maximum}" if @maximum
+          options_desc << "within the range of #{@within}" if @within
+          options_desc << "as exactly #{@is}" if @is
+          options_desc << "with message '#{@expected_message}'" if @expected_message
+          super << " #{options_desc.to_sentence}"
+        end
+
+        private
+
+        def check_maximum
+          if actual_max.nil?
+            @negative_result_message << " with no maximum"
+            @result = false
+          elsif actual_max == @maximum
+            @positive_result_message << " with maximum of #{@maximum}"
+          else
+            @negative_result_message << " with maximum of #{actual_max}"
+            @result = false
+          end
+        end
+
+        def check_minimum
+          if actual_min.nil?
+            @negative_result_message << " with no minimum"
+            @result = false
+          elsif actual_min == @minimum
+            @positive_result_message << " with minimum of #{@minimum}"
+          else
+            @negative_result_message << " with minimum of #{actual_min}"
+            @result = false
+          end
+        end
+
+        def check_range
+          min, max = [@within.min, @within.max]
+          if !actual_min.nil? and actual_max.nil?
+            @negative_result_message << " with no minimum but with maximum of #{actual_max}"
+            @result = false
+          elsif actual_min.nil? and !actual_max.nil?
+            @negative_result_message << " with minimum_of #{actual_min} but no maximum"
+            @result = false
+          elsif actual_min.nil? and actual_max.nil?
+            @negative_result_message << " with no minimum and maximum"
+            @result = false
+          elsif actual_min == min && actual_max == max
+            @positive_result_message << " within the range of #{@within.inspect}"
+          else
+            @negative_result_message << " within the range of #{(actual_min..actual_max).inspect}"
+            @result = false
+          end
+        end
+
+        def check_exact
+          if actual_is == @is
+            @positive_result_message << " as exactly #{@is}"
+          else
+            @negative_result_message << " as exactly #{actual_is}"
+            @result = false
+          end
+        end
+
+        def check_expected_message
+          actual_message = @validator.options[:message]
+          if actual_message.nil?
+            @negative_result_message << " with no custom message"
+            @result = false
+          elsif actual_message == @expected_message
+            @positive_result_message << " with custom message '#{@expected_message}'"
+          else
+            @negative_result_message << " got message '#{actual_message}'"
+            @result = false
+          end
+        end
+
+        def actual_is
+          actual_is = @validator.options[:is]
+        end
+
+        def actual_min
+          @validator.options[:minimum] || ((@validator.options[:in] || @validator.options[:within]).try(&:min))
+        end
+
+        def actual_max
+          @validator.options[:maximum] || ((@validator.options[:in] || @validator.options[:within]).try(&:max))
+        end
+      end
+
+      def validate_length_of(field)
+        ValidateLengthOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/numericality_of.rb

@@ -0,0 +1,90 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateNumericalityOfMatcher < HaveValidationMatcher
+        ALLOWED_OPTIONS =
+          %i(
+            allow_nil
+            equal_to
+            even
+            greater_than
+            greater_than_or_equal_to
+            less_than
+            less_than_or_equal_to
+            nil
+            odd
+            only_integer
+          )
+
+        def initialize(field)
+          super(field, :numericality)
+          @options = {}
+        end
+
+        def to_allow(options)
+          options[:equal_to] = options if options.is_a?(Numeric)
+          options[:allow_nil] = options.delete(:nil) if options.has_key?(:nil)
+
+          if !options.is_a?(Hash) || options.empty? || (options.keys - ALLOWED_OPTIONS).any?
+            message =
+              "validate_numericality_of#to_allow requires a Hash parameter containing" \
+              "any of the following keys: #{ALLOWED_OPTIONS.map(&:inspect).join(", ")}"
+            raise ArgumentError, message
+          end
+
+          @options.merge!(options)
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          @options.each do |comparator, expected_value|
+            result &= (@validator.options[comparator] == expected_value)
+          end
+
+          @positive_result_message <<= options_message(@validator.options)
+          @negative_result_message <<= options_message(@validator.options)
+          result
+        end
+
+        def description
+          super << options_message(@options)
+        end
+
+        protected
+
+        def options_message(options)
+          type_msg = []
+          comp_msg = []
+          options.each_pair do |key, value|
+            case key
+            when :allow_nil
+            when :only_integer
+              type_msg << "integer" if value
+            when :odd, :even
+              type_msg << "#{key.to_s}-numbered" if value
+            else
+              comp_msg << "#{key.to_s.gsub("_", " ")} #{value.inspect}"
+            end
+          end
+          allow_nil = (options[:allow_nil] ? "nil" : "non-nil") if options.has_key?(:allow_nil)
+          ["", "allowing", allow_nil, type_msg.any? ? type_msg.to_sentence : nil, "values", comp_msg.any? ? comp_msg.to_sentence : nil].compact.join(" ")
+        end
+
+        def method_missing(m, *args, &block)
+          if ALLOWED_OPTIONS.include?(m.to_sym)
+            raise ArgumentError, "wrong number of arguments (#{args.length} for 1)" if args.length > 1
+            send :to_allow, m.to_sym => args.first
+          else
+            super
+          end
+        end
+      end
+
+      def validate_numericality_of(field)
+        ValidateNumericalityOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/presence_of.rb

@@ -0,0 +1,9 @@
+module Mongoid
+  module Matchers
+    module Validations
+      def validate_presence_of(field)
+        HaveValidationMatcher.new(field, :presence)
+      end
+    end
+  end
+end

data/lib/matchers/validations/uniqueness_of.rb

@@ -0,0 +1,82 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateUniquenessOfMatcher < HaveValidationMatcher
+        include WithMessage
+        def initialize(field)
+          super(field, :uniqueness)
+        end
+
+        def scoped_to(*scope)
+          @scope = [scope].flatten.map(&:to_sym)
+          self
+        end
+        alias_method :scoped_on, :scoped_to
+
+        def case_insensitive
+          @case_insensitive = true
+          self
+        end
+
+        def allow_blank?(allow_blank)
+          @allow_blank = allow_blank
+          self
+        end
+
+        def matches?(actual)
+          return false unless @result = super(actual)
+
+          check_scope if @scope
+          check_allow_blank if @allow_blank
+          check_case_sensitivity if @case_insensitive
+          check_expected_message if @expected_message
+
+          @result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " scoped to #{@scope.inspect}" if @scope
+          options_desc << " allowing blank values" if @allow_blank
+          options_desc << " allowing case insensitive values" if @case_insensitive
+          options_desc << " with message '#{@expected_message}'" if @expected_message
+          super << options_desc.to_sentence
+        end
+
+        private
+
+        def check_allow_blank
+          if @validator.options[:allow_blank] == @allow_blank
+            @positive_result_message << " with blank values allowed"
+          else
+            @negative_result_message << " with no blank values allowed"
+            @result = false
+          end
+        end
+
+        def check_scope
+          message = " scope to #{@validator.options[:scope]}"
+          if [@validator.options[:scope]].flatten.map(&:to_sym) == @scope
+            @positive_result_message << message
+          else
+            @negative_result_message << message
+            @result = false
+          end
+        end
+
+        def check_case_sensitivity
+          if @validator.options[:case_sensitive] == false
+            @positive_result_message << " with case insensitive values"
+          else
+            @negative_result_message << " without case insensitive values"
+            @result = false
+          end
+        end
+      end
+
+      def validate_uniqueness_of(field)
+        ValidateUniquenessOfMatcher.new(field)
+      end
+    end
+  end
+end