mongoid-rspec 1.5.0 → 1.11.0

data/lib/matchers/document.rb

@@ -5,11 +5,21 @@ module Mongoid
         @attributes = attrs.collect(&:to_s)
       end
 
+      def localized
+        @localized = true
+        self
+      end
+
       def of_type(type)
         @type = type
         self
       end
 
+      def with_alias(field_alias)
+        @field_alias = field_alias
+        self
+      end
+
       def with_default_value_of(default)
         @default = default
         self
@@ -25,11 +35,26 @@ module Mongoid
               error << " of type #{@klass.fields[attr].type}"
             end
 
-            if !@default.nil? and !@klass.fields[attr].default_val.nil? and @klass.fields[attr].default_val != @default
-              error << " with default value of #{@klass.fields[attr].default_val}"
+            if !@default.nil?
+              if @klass.fields[attr].default_val.nil?
+                error << " with default not set"
+              elsif @klass.fields[attr].default_val != @default
+                error << " with default value of #{@klass.fields[attr].default_val}"
+              end
+            end
+
+            if @field_alias and @klass.fields[attr].options[:as] != @field_alias
+              error << " with alias #{@klass.fields[attr].options[:as]}"
             end
 
             @errors.push("field #{attr.inspect}" << error) unless error.blank?
+
+            if @localized
+              unless @klass.fields[attr].localized?
+                @errors.push "is not localized #{attr.inspect}"
+              end
+            end
+
           else
             @errors.push "no field named #{attr.inspect}"
           end
@@ -48,6 +73,7 @@ module Mongoid
       def description
         desc = "have #{@attributes.size > 1 ? 'fields' : 'field'} named #{@attributes.collect(&:inspect).to_sentence}"
         desc << " of type #{@type.inspect}" if @type
+        desc << " with alias #{@field_alias}" if @field_alias
         desc << " with default value of #{@default.inspect}" if !@default.nil?
         desc
       end
@@ -92,11 +118,24 @@ end
 
 RSpec::Matchers.define :be_timestamped_document do
   match do |doc|
-    doc.class.included_modules.include?(Mongoid::Timestamps)
+    if [*@timestamped_module].any?
+      modules = [*@timestamped_module].map{|m| "Mongoid::Timestamps::#{m.to_s.classify}".constantize }
+      (modules - doc.class.included_modules).empty?
+    else
+      doc.class.included_modules.include?(Mongoid::Timestamps) or
+      doc.class.included_modules.include?(Mongoid::Timestamps::Created) or
+      doc.class.included_modules.include?(Mongoid::Timestamps::Updated)
+    end
+  end
+
+  chain :with do |timestamped_module|
+    @timestamped_module = timestamped_module
   end
 
   description do
-    "be a timestamped Mongoid document"
+    desc = "be a timestamped Mongoid document"
+    desc << " with #{@timestamped_module}" if @timestamped_module
+    desc
   end
 end
 

data/lib/matchers/indexes.rb

@@ -2,33 +2,32 @@ module Mongoid
   module Matchers
     class HaveIndexForMatcher # :nodoc:
       def initialize(index_fields)
-        @index_fields = index_fields
+        @index_fields = index_fields.symbolize_keys!
       end
-      
-      def with_options(options = {})
+
+      def with_options(options = { })
         @options = options
         self
       end
-      
+
       def matches?(klass)
-        @klass = klass.is_a?(Class) ? klass : klass.class
+        @klass  = klass.is_a?(Class) ? klass : klass.class
         @errors = []
-        
         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 @klass.index_options[@index_fields].include?(option) && @klass.index_options[@index_fields][option] != option_value
+              if denormalising_options(@klass.index_options[@index_fields])[option] != option_value
                 @errors.push "index for #{@index_fields.inspect} with options of #{@klass.index_options[@index_fields].inspect}"
               end
             end
           end
         end
-        
+
         @errors.empty?
       end
-      
+
       def failure_message_for_should
         "Expected #{@klass.inspect} to #{description}, got #{@errors.to_sentence}"
       end
@@ -42,8 +41,21 @@ module Mongoid
         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

data/lib/matchers/validations/acceptance_of.rb

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

data/lib/matchers/validations/associated.rb

@@ -1,19 +1,19 @@
 module Mongoid
   module Matchers
-    module Validations  
+    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
-end  
+end

data/lib/matchers/validations/confirmation_of.rb

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

data/lib/matchers/validations/custom_validation_of.rb

@@ -2,6 +2,7 @@ module Mongoid
   module Matchers
     module Validations
       class ValidateWithCustomValidatorMatcher < HaveValidationMatcher
+        include WithMessage
         def initialize(field)
           super(field, :custom)
         end
@@ -11,11 +12,6 @@ module Mongoid
           self
         end
 
-        def with_message(message)
-          @expected_message = message
-          self
-        end
-
         def matches?(actual)
           return false unless (@result = super(actual))
           check_custom_validator if @custom_validator
@@ -41,19 +37,6 @@ module Mongoid
             @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
       end
 
       def custom_validate(field)
@@ -61,4 +44,4 @@ module Mongoid
       end
     end
   end
-end
+end

data/lib/matchers/validations/exclusion_of.rb

@@ -15,7 +15,14 @@ module Mongoid
           return false unless result = super(actual)
 
           if @not_allowed_values
-            allowed_values = @not_allowed_values - @validator.options[:in]
+            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

data/lib/matchers/validations/format_of.rb

@@ -1,71 +1,71 @@
 module Mongoid
   module Matchers
-    module Validations  
+    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          
+          self
         end
-        
+
         def not_to_allow(invalid_value)
           @invalid_value = invalid_value
-          self          
+          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
           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
           end
-          
-          if @invalid_value  
+
+          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
           end
-          
-          result          
+
+          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                    
+          options_desc << " not allowing the value #{@invalid_value.inspect}" if @invalid_value
           super << options_desc.to_sentence
-        end        
+        end
       end
 
       def validate_format_of(field)
         ValidateFormatOfMatcher.new(field)
-      end           
+      end
     end
   end
-end  
+end

data/lib/matchers/validations/inclusion_of.rb

@@ -1,42 +1,49 @@
 module Mongoid
   module Matchers
-    module Validations  
+    module Validations
       class ValidateInclusionOfMatcher < HaveValidationMatcher
         def initialize(name)
           super(name, :inclusion)
         end
-        
+
         def to_allow(*values)
           @allowed_values = values.map(&:to_a).flatten
           self
         end
-        
+
         def matches?(actual)
           return false unless result = super(actual)
-          
+
           if @allowed_values
-            not_allowed_values = @allowed_values - @validator.options[:in].to_a
+            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 the following the ff. values: #{not_allowed_values.inspect}"
+              @negative_result_message = @negative_result_message << " not allowing these values: #{not_allowed_values.inspect}"
               result = false
             end
           end
-          
-          result          
+
+          result
         end
-        
+
         def description
           options_desc = []
-          options_desc << " allowing the ff. values: #{@allowed_values}" if @allowed_values                
+          options_desc << " allowing these values: #{@allowed_values}" if @allowed_values
           super << options_desc.to_sentence
-        end 
+        end
       end
 
       def validate_inclusion_of(field)
         ValidateInclusionOfMatcher.new(field)
-      end       
+      end
     end
   end
-end  
+end

data/lib/matchers/validations/length_of.rb

@@ -2,6 +2,8 @@ module Mongoid
   module Matchers
     module Validations
       class ValidateLengthOfMatcher < HaveValidationMatcher
+        include WithMessage
+
         def initialize(name)
           super(name, :length)
         end
@@ -10,11 +12,13 @@ module Mongoid
           @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
@@ -28,6 +32,11 @@ module Mongoid
         end
         alias :is :as_exactly
 
+        def with_message(message)
+          @expected_message = message
+          self
+        end
+
         def matches?(actual)
           return false unless @result = super(actual)
 
@@ -35,61 +44,99 @@ module Mongoid
           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 maximum #{@maximum}" if @maximum
-          options_desc << " with minimum #{@minimum}" if @minimum
-          options_desc << " within range #{@within}" if @within
-          options_desc << " as exactly #{@is}" if @is
-          super << options_desc.to_sentence
+          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
-          actual = @validator.options[:maximum]
-          if actual == @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}"
+            @negative_result_message << " with maximum of #{actual_max}"
             @result = false
           end
         end
 
         def check_minimum
-          actual = @validator.options[:minimum]
-          if actual == @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}"
+            @negative_result_message << " with minimum of #{actual_min}"
             @result = false
           end
         end
 
         def check_range
           min, max = [@within.min, @within.max]
-          actual = @validator.options
-          if actual[:minimum] == min && actual[:maximum] == max
-            @positive_result_message << " with range #{@within.inspect}"
+          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 << " with range #{(actual[:minimum]..actual[:maximum]).inspect}"
+            @negative_result_message << " within the range of #{(actual_min..actual_max).inspect}"
             @result = false
           end
         end
 
         def check_exact
-          actual = @validator.options[:is]
-          if actual == @is
-            @positive_result_message << " is exactly #{@is}"
+          if actual_is == @is
+            @positive_result_message << " as exactly #{@is}"
           else
-            @negative_result_message << " is exactly #{actual}"
+            @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)

data/lib/matchers/validations/numericality_of.rb

@@ -2,14 +2,14 @@ module Mongoid
   module Matchers
     module Validations
       class ValidateNumericalityOfMatcher < HaveValidationMatcher
-        @@allowed_options = [:equal_to, :greater_than, :greater_than_or_equal_to, :less_than, :less_than_or_equal_to, 
+        @@allowed_options = [:equal_to, :greater_than, :greater_than_or_equal_to, :less_than, :less_than_or_equal_to,
           :even, :odd, :only_integer, :allow_nil, :nil]
-        
+
         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)
@@ -21,7 +21,7 @@ module Mongoid
 
         def matches?(actual)
           return false unless result = super(actual)
-          
+
           @@allowed_options.each do |comparator|
             if @options.has_key?(comparator) and !([:even, :odd, :only_integer].include?(comparator) and !@validator.options.include?(comparator))
               result &= (@validator.options[comparator] == @options[comparator])
@@ -35,12 +35,12 @@ module Mongoid
         def description
           super << options_message(@options)
         end
-        
+
         protected
-        
+
         def options_message(options)
           type_msg = []
-          comp_msg = []          
+          comp_msg = []
           options.each_pair do |key, value|
             case key
             when :allow_nil
@@ -52,10 +52,10 @@ module Mongoid
               comp_msg << "#{key.to_s.gsub("_", " ")} #{value.inspect}"
             end
           end
-          allow_nil = (options[:allow_nil] ? "nil" : "non-nil") if options.has_key?(:allow_nil)          
+          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        
-        
+        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

data/lib/matchers/validations/presence_of.rb

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