mongoid-rspec 1.5.3 → 2.0.0

data/lib/matchers/associations.rb

@@ -12,16 +12,11 @@ module Mongoid
       EMBEDS_ONE = Mongoid::Relations::Embedded::One
       EMBEDDED_IN = Mongoid::Relations::Embedded::In
 
-
       class HaveAssociationMatcher
         def initialize(name, association_type)
           @association = {}
           @association[:name] = name.to_s
           @association[:type] = association_type
-          # begin
-          #   @association[:class] = name.to_s.classify.constantize
-          # rescue
-          # end
           @expectation_message = "#{type_description} #{@association[:name].inspect}"
           @expectation_message << " of type #{@association[:class].inspect}" unless @association[:class].nil?
         end
@@ -39,6 +34,19 @@ module Mongoid
           self
         end
 
+        def ordered_by(association_field_name)
+          raise "#{@association[:type].inspect} does not respond to :order" unless [HAS_MANY, HAS_AND_BELONGS_TO_MANY, EMBEDS_MANY].include?(@association[:type])
+          @association[:order] = association_field_name.to_s
+          @expectation_message << " ordered by #{@association[:order].inspect}"
+
+          if association_field_name.is_a? Origin::Key
+            @association[:order_operator] = association_field_name.operator
+            @expectation_message << " #{order_way(@association[:order_operator])}"
+          end
+
+          self
+        end
+
         def with_dependent(method_name)
           @association[:dependent] = method_name
           @expectation_message << " which specifies dependent as #{@association[:dependent].to_s}"
@@ -57,8 +65,34 @@ module Mongoid
           self
         end
 
+        def with_autobuild
+          @association[:autobuild] = true
+          @expectation_message << " which specifies autobuild as #{@association[:autobuild].to_s}"
+          self
+        end
+
+        def with_polymorphism
+          @association[:polymorphic] = true
+          @expectation_message << " which specifies polymorphic as #{@association[:polymorphic].to_s}"
+          self
+        end
+
+        def with_cascading_callbacks
+          @association[:cascade_callbacks] = true
+          @expectation_message << " which specifies cascade_callbacks as #{@association[:cascade_callbacks].to_s}"
+          self
+        end
+
+        def cyclic
+          @association[:cyclic] = true
+          @expectation_message << " which specifies cyclic as #{@association[:cyclic].to_s}"
+          self
+        end
+
         def stored_as(store_as)
-          raise NotImplementedError, "`references_many #{@association[:name]} :stored_as => :array` has been removed in Mongoid 2.0.0.rc, use `references_and_referenced_in_many #{@association[:name]}` instead"
+          @association[:store_as] = store_as.to_s
+          @expectation_message << " which is stored as #{@association[:store_as].inspect}"
+          self
         end
 
         def with_foreign_key(foreign_key)
@@ -102,6 +136,24 @@ module Mongoid
             end
           end
 
+          if @association[:order]
+            if @association[:order].to_s != metadata.order.to_s
+              @negative_result_message = "#{@positive_result_message} ordered by #{metadata.order}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} ordered by #{metadata.order}"
+            end
+          end
+
+          if @association[:order_operator]
+            if @association[:order_operator] != metadata.order.operator
+              @negative_result_message = "#{@positive_result_message} #{order_way(@association[:order_operator] * -1)}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} #{order_way(@association[:order_operator])}"
+            end
+          end
+
           if @association[:dependent]
             if @association[:dependent].to_s != metadata.dependent.to_s
               @negative_result_message = "#{@positive_result_message} which specified dependent as #{metadata.dependent}"
@@ -120,6 +172,51 @@ module Mongoid
             end
           end
 
+          if @association[:autobuild]
+            if metadata.autobuilding? != true
+              @negative_result_message = "#{@positive_result_message} which did not set autobuild"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set autobuild"
+            end
+          end
+
+          if @association[:polymorphic]
+            if metadata.polymorphic? != true
+              @negative_result_message = "#{@positive_result_message} which did not set polymorphic"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set polymorphic"
+            end
+          end
+
+          if @association[:cascade_callbacks]
+            if metadata.cascading_callbacks? != true
+              @negative_result_message = "#{@positive_result_message} which did not set cascade_callbacks"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set cascade_callbacks"
+            end
+          end
+
+          if @association[:cyclic]
+            if metadata.cyclic? != true
+              @negative_result_message = "#{@positive_result_message} which did not set cyclic"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set cyclic"
+            end
+          end
+
+          if @association[:store_as]
+            if metadata.store_as != @association[:store_as]
+              @negative_result_message = "#{@positive_result_message} which is stored as #{metadata.store_as}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which is stored as #{metadata.store_as}"
+            end
+          end
+
           if @association[:index]
             if metadata.index != true
               @negative_result_message = "#{@positive_result_message} which did not set index"
@@ -149,6 +246,9 @@ module Mongoid
           "Expected #{@actual.inspect} to not #{@expectation_message}, got #{@positive_result_message}"
         end
 
+        alias :failure_message :failure_message_for_should
+        alias :failure_message_when_negated :failure_message_for_should_not
+
         def description
           @expectation_message
         end
@@ -156,24 +256,29 @@ module Mongoid
         def type_description(type = nil, passive = true)
           type ||= @association[:type]
           case type.name
-          when EMBEDS_ONE.name
-            (passive ? 'embed' : 'embeds') << ' one'
-          when EMBEDS_MANY.name
-            (passive ? 'embed' : 'embeds') << ' many'
-          when EMBEDDED_IN.name
-            (passive ? 'be' : 'is') << ' embedded in'
-          when HAS_ONE.name
-            (passive ? 'reference' : 'references') << ' one'
-          when HAS_MANY.name
-            (passive ? 'reference' : 'references') << ' many'
-          when HAS_AND_BELONGS_TO_MANY.name
-            (passive ? 'reference' : 'references') << ' and referenced in many'
-          when BELONGS_TO.name
-            (passive ? 'be referenced in' : 'referenced in')
-          else
-            raise "Unknown association type '%s'" % type
+            when EMBEDS_ONE.name
+              (passive ? 'embed' : 'embeds') << ' one'
+            when EMBEDS_MANY.name
+              (passive ? 'embed' : 'embeds') << ' many'
+            when EMBEDDED_IN.name
+              (passive ? 'be' : 'is') << ' embedded in'
+            when HAS_ONE.name
+              (passive ? 'reference' : 'references') << ' one'
+            when HAS_MANY.name
+              (passive ? 'reference' : 'references') << ' many'
+            when HAS_AND_BELONGS_TO_MANY.name
+              (passive ? 'reference' : 'references') << ' and referenced in many'
+            when BELONGS_TO.name
+              (passive ? 'be referenced in' : 'referenced in')
+            else
+              raise "Unknown association type '%s'" % type
           end
         end
+
+        private
+          def order_way(operator)
+            [nil, "ascending", "descending"][operator]
+          end
       end
 
       def embed_one(association_name)

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
@@ -45,9 +70,13 @@ module Mongoid
         "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 #{@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

data/lib/matchers/indexes.rb

@@ -2,33 +2,50 @@ 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}"
+
+        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 #{@klass.index_options[@index_fields].inspect}"
+                end
+              end
+            end
+          end
         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
-                @errors.push "index for #{@index_fields.inspect} with options of #{@klass.index_options[@index_fields].inspect}"
+          # 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 #{index_options.inspect}"
+                end
               end
             end
           end
         end
-        
+
         @errors.empty?
       end
-      
+
       def failure_message_for_should
         "Expected #{@klass.inspect} to #{description}, got #{@errors.to_sentence}"
       end
@@ -37,13 +54,29 @@ module Mongoid
         "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

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,23 +1,23 @@
 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
+          @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 
+            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
@@ -26,24 +26,24 @@ module Mongoid
             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