mongoid-rspec 2.1.0 → 4.1.0

data/lib/matchers/have_timestamps.rb

@@ -0,0 +1,61 @@
+module Mongoid
+  module Matchers
+    def have_timestamps
+      HaveTimestamps.new
+    end
+
+    class HaveTimestamps
+      def initialize
+        @root_module = 'Mongoid::Timestamps'
+      end
+
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        @model.included_modules.include?(expected_module)
+      end
+
+      def for(phase)
+        raise('You\'ve already declared timetamp\'s sub-module via "for" clause') if @submodule
+
+        case @phase = phase.to_sym
+        when :creating then @submodule = 'Created'
+        when :updating then @submodule = 'Updated'
+        else
+          raise('Timestamps can be declared only for creating or updating')
+        end
+
+        self
+      end
+
+      def shortened
+        @shortened = true
+        self
+      end
+
+      def description
+        desc = 'be a Mongoid document with'
+        desc << ' shorted' if @shortened
+        desc << " #{@phase}" if @phase
+        desc << ' timestamps'
+        desc
+      end
+
+      def failure_message
+        "Expected #{@model.inspect} class to #{description}"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@model.inspect} class to not #{description}"
+      end
+
+      private
+
+      def expected_module
+        expected_module = @root_module
+        expected_module << "::#{@submodule}" if @submodule
+        expected_module << '::Short' if @shortened
+        expected_module.constantize
+      end
+    end
+  end
+end

data/lib/matchers/indexes/have_index_for.rb

@@ -0,0 +1,16 @@
+module Mongoid
+  module Matchers
+    class HaveIndexForBase
+      attr_reader :index_key, :index_options, :model
+
+      def initialize(index_key)
+        @index_key = index_key.symbolize_keys
+      end
+
+      def with_options(index_options = {})
+        @index_options = index_options
+        self
+      end
+    end
+  end
+end

data/lib/matchers/indexes/v3/have_index_for.rb

@@ -0,0 +1,59 @@
+module Mongoid
+  module Matchers
+    def have_index_for(index_key)
+      HaveIndexFor.new(index_key)
+    end
+
+    class HaveIndexFor < Mongoid::Matchers::HaveIndexForBase
+      def matches?(klass)
+        @model  = klass.is_a?(Class) ? klass : klass.class
+        @errors = []
+
+        if model.index_options[index_key]
+          if !index_options.nil? && !index_options.empty?
+            index_options.each do |option, option_value|
+              if denormalising_options(model.index_options[index_key])[option] != option_value
+                @errors.push "index for #{index_key.inspect} with options of #{model.index_options[index_key].inspect}"
+              end
+            end
+          end
+        else
+          @errors.push "no index for #{index_key}"
+        end
+
+        @errors.empty?
+      end
+
+      def failure_message_for_should
+        "Expected #{model.inspect} to #{description}, got #{@errors.to_sentence}"
+      end
+
+      def failure_message_for_should_not
+        "Expected #{model.inspect} to not #{description}, got #{model.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_key.inspect}"
+        desc << " with options of #{index_options.inspect}" if index_options
+        desc
+      end
+
+      private
+
+      MAPPINGS = {
+        dropDups: :drop_dups
+      }.freeze
+
+      def denormalising_options(opts)
+        options = {}
+        opts.each_pair do |option, value|
+          options[MAPPINGS[option] || option] = value
+        end
+        options
+      end
+    end
+  end
+end

data/lib/matchers/indexes/v4/have_index_for.rb

@@ -0,0 +1,54 @@
+module Mongoid
+  module Matchers
+    def have_index_for(index_key)
+      HaveIndexFor.new(index_key)
+    end
+
+    class HaveIndexFor < Mongoid::Matchers::HaveIndexForBase
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+
+        actual_index &&
+          expected_index.key == actual_index.key &&
+          expected_index.fields == actual_index.fields &&
+          (expected_index.options.to_a - actual_index.options.to_a).empty?
+      end
+
+      def failure_message
+        message = "Expected #{model.inspect} to #{description},"
+        message << if actual_index.nil?
+                     ' found no index'
+                   else
+                     " got #{index_description(actual_index)}"
+                   end
+        message
+      end
+
+      def failure_message_when_negated
+        "Expected #{model.inspect} to not #{description}, got #{index_description(actual_index)}"
+      end
+
+      def description
+        "have an index #{index_description(expected_index)}"
+      end
+
+      private
+
+      def index_description(index)
+        desc = index.key.inspect.to_s
+        desc << " for fields #{index.fields.inspect}" if index.fields.present?
+        desc << " including options #{index.options.inspect}" if index.options.present?
+        desc
+      end
+
+      def expected_index
+        @expected_index ||=
+          Mongoid::Indexable::Specification.new(model, index_key, index_options)
+      end
+
+      def actual_index
+        @actual_index ||= model.index_specification(expected_index.key)
+      end
+    end
+  end
+end

data/lib/matchers/validations.rb

@@ -1,9 +1,7 @@
 module Mongoid
   module Matchers
     module Validations
-
       class HaveValidationMatcher
-
         def initialize(field, validation_type)
           @field = field.to_s
           @type = validation_type.to_s
@@ -13,9 +11,9 @@ module Mongoid
         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))
-          }
+          @validator = @klass.validators_on(@field).detect do |v|
+            (v.kind.to_s == @type) && (!v.options[:on] || on_options_matches?(v))
+          end
 
           if @validator
             @negative_result_message = "#{@type.inspect} validator on #{@field.inspect}"
@@ -26,6 +24,7 @@ module Mongoid
           end
           @result = true
           check_on if @options[:on]
+          check_expected_message if @expected_message
           @result
         end
 
@@ -37,12 +36,14 @@ module Mongoid
           "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
+        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 << " with message #{@expected_message.inspect}" if @expected_message
+
           desc
         end
 
@@ -51,13 +52,20 @@ module Mongoid
           self
         end
 
+        def with_message(message)
+          @expected_message = message
+          self
+        end
+
+        private
+
         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 )
+            if on_options_covered_by?(@validator)
               @positive_result_message << message
             else
               @negative_result_message << message
@@ -66,15 +74,26 @@ module Mongoid
           end
         end
 
-        private
-
         def on_options_matches?(validator)
-          @options[:on] and validator.options[:on] and on_options_covered_by?(validator)
+          @options[:on] && validator.options[:on] && on_options_covered_by?(validator)
         end
 
         def on_options_covered_by?(validator)
           ([@options[:on]].flatten - [validator.options[:on]].flatten).empty?
         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
     end
   end

data/lib/matchers/validations/absence_of.rb

@@ -0,0 +1,11 @@
+if Mongoid::Compatibility::Version.mongoid4_or_newer?
+  module Mongoid
+    module Matchers
+      module Validations
+        def validate_absence_of(field)
+          HaveValidationMatcher.new(field, :absence)
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/associated.rb

@@ -16,4 +16,4 @@ module Mongoid
       end
     end
   end
-end
+end

data/lib/matchers/validations/confirmation_of.rb

@@ -1,8 +1,14 @@
 module Mongoid
   module Matchers
     module Validations
+      class ValidateConfirmationOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :confirmation)
+        end
+      end
+
       def validate_confirmation_of(field)
-        HaveValidationMatcher.new(field, :confirmation)
+        ValidateConfirmationOfMatcher.new(field)
       end
     end
   end

data/lib/matchers/validations/custom_validation_of.rb

@@ -2,7 +2,6 @@ module Mongoid
   module Matchers
     module Validations
       class ValidateWithCustomValidatorMatcher < HaveValidationMatcher
-        include WithMessage
         def initialize(field)
           super(field, :custom)
         end
@@ -15,7 +14,6 @@ module Mongoid
         def matches?(actual)
           return false unless (@result = super(actual))
           check_custom_validator if @custom_validator
-          check_expected_message if @expected_message
 
           @result
         end
@@ -23,14 +21,13 @@ module Mongoid
         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
+          if @validator.is_a? @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}"

data/lib/matchers/validations/exclusion_of.rb

@@ -18,13 +18,13 @@ module Mongoid
             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
+                                           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"
+              @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
@@ -46,4 +46,4 @@ module Mongoid
       end
     end
   end
-end
+end

data/lib/matchers/validations/format_of.rb

@@ -43,7 +43,7 @@ module Mongoid
           end
 
           if @invalid_value
-            if !(@invalid_value =~ @validator.options[:with])
+            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"
@@ -68,4 +68,4 @@ module Mongoid
       end
     end
   end
-end
+end

data/lib/matchers/validations/inclusion_of.rb

@@ -18,13 +18,13 @@ module Mongoid
             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
+                                       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"
+              @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
@@ -46,4 +46,4 @@ module Mongoid
       end
     end
   end
-end
+end

data/lib/matchers/validations/length_of.rb

@@ -2,8 +2,6 @@ module Mongoid
   module Matchers
     module Validations
       class ValidateLengthOfMatcher < HaveValidationMatcher
-        include WithMessage
-
         def initialize(name)
           super(name, :length)
         end
@@ -12,30 +10,25 @@ module Mongoid
           @maximum = value
           self
         end
-        alias :less_than :with_maximum
+        alias less_than with_maximum
 
         def with_minimum(value)
           @minimum = value
           self
         end
-        alias :greater_than :with_minimum
+        alias greater_than with_minimum
 
         def within(value)
           @within = value
           self
         end
-        alias :in :within
+        alias in within
 
         def as_exactly(value)
           @is = value
           self
         end
-        alias :is :as_exactly
-
-        def with_message(message)
-          @expected_message = message
-          self
-        end
+        alias is as_exactly
 
         def matches?(actual)
           return false unless @result = super(actual)
@@ -44,7 +37,6 @@ module Mongoid
           check_minimum if @minimum
           check_range if @within
           check_exact if @is
-          check_expected_message if @expected_message
 
           @result
         end
@@ -55,7 +47,6 @@ module Mongoid
           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
 
@@ -63,7 +54,7 @@ module Mongoid
 
         def check_maximum
           if actual_max.nil?
-            @negative_result_message << " with no maximum"
+            @negative_result_message << ' with no maximum'
             @result = false
           elsif actual_max == @maximum
             @positive_result_message << " with maximum of #{@maximum}"
@@ -75,7 +66,7 @@ module Mongoid
 
         def check_minimum
           if actual_min.nil?
-            @negative_result_message << " with no minimum"
+            @negative_result_message << ' with no minimum'
             @result = false
           elsif actual_min == @minimum
             @positive_result_message << " with minimum of #{@minimum}"
@@ -86,15 +77,15 @@ module Mongoid
         end
 
         def check_range
-          min, max = [@within.min, @within.max]
-          if !actual_min.nil? and actual_max.nil?
+          min, max = @within.minmax
+          if !actual_min.nil? && 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?
+          elsif actual_min.nil? && !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"
+          elsif actual_min.nil? && 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}"
@@ -113,29 +104,16 @@ module Mongoid
           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))
+          @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))
+          @validator.options[:maximum] || (@validator.options[:in] || @validator.options[:within]).try(&:max)
         end
       end