mongoid-rspec-multi-db 1.4.4

data/lib/matchers/indexes.rb

@@ -0,0 +1,51 @@
+module Mongoid
+  module Matchers
+    class HaveIndexForMatcher # :nodoc:
+      def initialize(index_fields)
+        @index_fields = index_fields
+      end
+      
+      def with_options(options = {})
+        @options = options
+        self
+      end
+      
+      def matches?(klass)
+        @klass = klass.is_a?(Class) ? klass : klass.class
+        @errors = []
+        
+        if @klass.index_options[@index_fields].nil?
+          @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
+                @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
+
+      def failure_message_for_should_not
+        "Expected #{@klass.inspect} to not #{description}, got #{@klass.inspect} to #{description}"
+      end
+
+      def description
+        desc = "have an index for #{@index_fields.inspect}"
+        desc << " with options of #{@options.inspect}" if @options
+        desc
+      end
+    end
+    
+    def have_index_for(index_fields)
+      HaveIndexForMatcher.new(index_fields)
+    end
+  end
+end

data/lib/matchers/validations.rb

@@ -0,0 +1,42 @@
+module Mongoid
+  module Matchers
+    module Validations  
+      
+      class HaveValidationMatcher
+      
+        def initialize(field, validation_type)
+          @field = field.to_s
+          @type = validation_type.to_s
+        end
+                
+        def matches?(actual)
+          @klass = actual.is_a?(Class) ? actual : actual.class
+          
+          @validator = @klass.validators_on(@field).detect{|v| v.kind.to_s == @type }
+          
+          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
+          
+          true
+        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
+        
+        def description
+          "validate #{@type} of #{@field.inspect}"
+        end
+      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/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,42 @@
+module Mongoid
+  module Matchers
+    module Validations  
+      class ValidateInclusionOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :inclusion)
+        end
+        
+        def to_allow(*values)
+          @allowed_values = [values].flatten
+          self
+        end
+        
+        def matches?(actual)
+          return false unless result = super(actual)
+          
+          if @allowed_values
+            not_allowed_values = @allowed_values - @validator.options[:in]
+            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}"
+              result = false
+            end
+          end
+          
+          result          
+        end
+        
+        def description
+          options_desc = []
+          options_desc << " allowing the ff. 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,100 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateLengthOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :length)
+        end
+
+        def with_maximum(value)
+          @maximum = value
+          self
+        end
+
+        def with_minimum(value)
+          @minimum = value
+          self
+        end
+
+        def within(value)
+          @within = value
+          self
+        end
+        alias :in :within
+
+        def as_exactly(value)
+          @is = value
+          self
+        end
+        alias :is :as_exactly
+
+        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
+
+          @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
+        end
+
+        private
+
+        def check_maximum
+          actual = @validator.options[:maximum]
+          if actual == @maximum
+            @positive_result_message << " with maximum of #{@maximum}"
+          else
+            @negative_result_message << " with maximum of #{actual}"
+            @result = false
+          end
+        end
+
+        def check_minimum
+          actual = @validator.options[:minimum]
+          if actual == @minimum
+            @positive_result_message << " with minimum of #{@minimum}"
+          else
+            @negative_result_message << " with minimum of #{actual}"
+            @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}"
+          else
+            @negative_result_message << " with range #{(actual[:minimum]..actual[:maximum]).inspect}"
+            @result = false
+          end
+        end
+
+        def check_exact
+          actual = @validator.options[:is]
+          if actual == @is
+            @positive_result_message << " is exactly #{@is}"
+          else
+            @negative_result_message << " is exactly #{actual}"
+            @result = false
+          end
+        end
+      end
+
+      def validate_length_of(field)
+        ValidateLengthOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/numericality_of.rb

@@ -0,0 +1,74 @@
+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, 
+          :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)
+          raise ArgumentError, "validate_numericality_of#to_allow requires a Hash parameter containing any of the following keys: " <<
+            @@allowed_options.map(&:inspect).join(", ") if !options.is_a?(Hash) or options.empty? or (options.keys - @@allowed_options).any?
+          @options.merge!(options)
+          self
+        end
+
+        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])
+            end
+          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,99 @@
+module Mongoid
+  module Matchers
+    module Validations  
+      class ValidateUniquenessOfMatcher < HaveValidationMatcher
+        def initialize(field)
+          super(field, :uniqueness)
+        end
+        
+        def scoped_to(*scope)
+          @scope = [scope].flatten
+          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 with_message(message)
+          @expected_message = message
+          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 @case_insensitive
+          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 == @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
+
+        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 validate_uniqueness_of(field)
+        ValidateUniquenessOfMatcher.new(field)
+      end       
+    end
+  end
+end