mongoid4-rspec 1.11.0

data/lib/matchers/indexes.rb

@@ -0,0 +1,84 @@
+module Mongoid
+  module Matchers
+    class HaveIndexForMatcher # :nodoc:
+      def initialize(index_fields)
+        @index_fields = index_fields.symbolize_keys!
+      end
+
+      def with_options(options = { })
+        @options = options
+        self
+      end
+
+      def matches?(klass)
+        @klass  = klass.is_a?(Class) ? klass : klass.class
+        @errors = []
+
+        if @klass.respond_to?(:index_options)
+          # Mongoid 3
+          unless @klass.index_options[@index_fields]
+            @errors.push "no index for #{@index_fields}"
+          else
+            if !@options.nil? && !@options.empty?
+              @options.each do |option, option_value|
+                if denormalising_options(@klass.index_options[@index_fields])[option] != option_value
+                  @errors.push "index for #{@index_fields.inspect} with options of #{index_options.inspect}"
+                end
+              end
+            end
+          end
+        else
+          # Mongoid 4
+          unless @klass.index_specifications.map(&:key).include?(@index_fields)
+            @errors.push "no index for #{@index_fields}"
+          else
+            if !@options.nil? && !@options.empty?
+              index_options = @klass.index_specifications.select { |is| is.key == @index_fields }.first.options
+              @options.each do |option, option_value|
+                if index_options[option] != option_value
+                  @errors.push "index for #{@index_fields.inspect} with options of #{@klass.index_options[@index_fields].inspect}"
+                end
+              end
+            end
+          end
+        end
+
+        @errors.empty?
+      end
+
+      def failure_message_for_should
+        "Expected #{@klass.inspect} to #{description}, got #{@errors.to_sentence}"
+      end
+
+      def failure_message_for_should_not
+        "Expected #{@klass.inspect} to not #{description}, got #{@klass.inspect} to #{description}"
+      end
+
+      alias :failure_message :failure_message_for_should
+      alias :failure_message_when_negated :failure_message_for_should_not
+
+      def description
+        desc = "have an index for #{@index_fields.inspect}"
+        desc << " with options of #{@options.inspect}" if @options
+        desc
+      end
+
+      private
+        MAPPINGS = {
+          dropDups: :drop_dups
+        }
+
+        def denormalising_options(opts)
+          options = {}
+          opts.each_pair do |option, value|
+            options[MAPPINGS[option] || option] = value
+          end
+          options
+        end
+    end
+
+    def have_index_for(index_fields)
+      HaveIndexForMatcher.new(index_fields)
+    end
+  end
+end

data/lib/matchers/validations.rb

@@ -0,0 +1,81 @@
+module Mongoid
+  module Matchers
+    module Validations
+
+      class HaveValidationMatcher
+
+        def initialize(field, validation_type)
+          @field = field.to_s
+          @type = validation_type.to_s
+          @options = {}
+        end
+
+        def matches?(actual)
+          @klass = actual.is_a?(Class) ? actual : actual.class
+
+          @validator = @klass.validators_on(@field).detect{ |v|
+            v.kind.to_s == @type and (!v.options[:on] or on_options_matches?(v))
+          }
+
+          if @validator
+            @negative_result_message = "#{@type.inspect} validator on #{@field.inspect}"
+            @positive_result_message = "#{@type.inspect} validator on #{@field.inspect}"
+          else
+            @negative_result_message = "no #{@type.inspect} validator on #{@field.inspect}"
+            return false
+          end
+          @result = true
+          check_on if @options[:on]
+          @result
+        end
+
+        def failure_message_for_should
+          "Expected #{@klass.inspect} to #{description}; instead got #{@negative_result_message}"
+        end
+
+        def failure_message_for_should_not
+          "Expected #{@klass.inspect} to not #{description}; instead got #{@positive_result_message}"
+        end
+
+        alias :failure_message :failure_message_for_should
+        alias :failure_message_when_negated :failure_message_for_should_not
+
+        def description
+          desc = "have #{@type.inspect} validator on #{@field.inspect}"
+          desc << " on #{@options[:on]}" if @options[:on]
+          desc
+        end
+
+        def on(*on_method)
+          @options[:on] = on_method.flatten
+          self
+        end
+
+        def check_on
+          validator_on_methods = [@validator.options[:on]].flatten
+
+          if validator_on_methods.any?
+            message = " on methods: #{validator_on_methods}"
+
+            if on_options_covered_by?( @validator )
+              @positive_result_message << message
+            else
+              @negative_result_message << message
+              @result = false
+            end
+          end
+        end
+
+        private
+
+        def on_options_matches?(validator)
+          @options[:on] and validator.options[:on] and on_options_covered_by?(validator)
+        end
+
+        def on_options_covered_by?(validator)
+          ([@options[:on]].flatten - [validator.options[:on]].flatten).empty?
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/acceptance_of.rb

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

data/lib/matchers/validations/associated.rb

@@ -0,0 +1,19 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateAssociatedMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :associated)
+        end
+
+        def description
+          "validate associated #{@field.inspect}"
+        end
+      end
+
+      def validate_associated(association_name)
+        ValidateAssociatedMatcher.new(association_name)
+      end
+    end
+  end
+end

data/lib/matchers/validations/confirmation_of.rb

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

data/lib/matchers/validations/custom_validation_of.rb

@@ -0,0 +1,47 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateWithCustomValidatorMatcher < HaveValidationMatcher
+        include WithMessage
+        def initialize(field)
+          super(field, :custom)
+        end
+
+        def with_validator(custom_validator)
+          @custom_validator = custom_validator
+          self
+        end
+
+        def matches?(actual)
+          return false unless (@result = super(actual))
+          check_custom_validator if @custom_validator
+          check_expected_message if @expected_message
+
+          @result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " with custom validator #{@custom_validator.name}" if @validator
+          options_desc << " with message '#{@expected_message}'" if @expected_message
+          "validate field #{@field.inspect}" << options_desc.to_sentence
+        end
+
+        private
+
+        def check_custom_validator
+          if @validator.kind_of? @custom_validator
+            @positive_result_message << " with custom validator of type #{@custom_validator.name}"
+          else
+            @negative_result_message << " with custom validator not of type #{@custom_validator.name}"
+            @result = false
+          end
+        end
+      end
+
+      def custom_validate(field)
+        ValidateWithCustomValidatorMatcher.new(field)
+      end
+    end
+  end
+end

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