mongoid-spec 4.0.1

data/lib/matchers/be_mongoid_document.rb

@@ -0,0 +1,26 @@
+module Mongoid
+  module Matchers
+    def be_mongoid_document
+      BeMongoidDocument.new
+    end
+
+    class BeMongoidDocument
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        @model.included_modules.include?(Mongoid::Document)
+      end
+
+      def description
+        'include Mongoid::Document'
+      end
+
+      def failure_message
+        "expect #{@model.inspect} class to #{description}"
+      end
+
+      def failure_message_when_negated
+        "expect #{@model.inspect} class to not #{description}"
+      end
+    end
+  end
+end

data/lib/matchers/be_stored_in.rb

@@ -0,0 +1,50 @@
+module Mongoid
+  module Matchers
+    def be_stored_in(options)
+      BeStoredIn.new(options)
+    end
+
+    class BeStoredIn
+      def initialize(expected)
+        @expected_options = \
+          expected
+            .transform_values { |v| v.to_sym rescue v }
+            .symbolize_keys
+      end
+
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        actual_options == @expected_options
+      end
+
+      def description
+        "be stored in #{@expected_options.inspect}"
+      end
+
+      def failure_message
+        "Expected #{@model.inspect} to #{description}, got #{actual_options.inspect}"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@model.inspect} not to #{description}, got #{actual_options.inspect}"
+      end
+
+      private
+
+      def actual_options
+        @actual_options ||= begin
+          hash = @model.storage_options.slice(*@expected_options.keys)
+          hash.each do |option, value|
+            hash[option] =
+              if value.is_a?(Proc)
+                evaluated_value = @model.persistence_context.send("#{option}_name")
+                evaluated_value.to_sym rescue evaluated_value
+              else
+                value.to_sym rescue value
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/matchers/have_field.rb

@@ -0,0 +1,90 @@
+module Mongoid
+  module Matchers
+    class HaveField # :nodoc:
+      def initialize(*attrs)
+        @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
+      end
+
+      def matches?(klass)
+        @klass = klass.is_a?(Class) ? klass : klass.class
+        @errors = []
+        @attributes.each do |attr|
+          if @klass.fields.include?(attr)
+            error = ""
+            if @type and @klass.fields[attr].type != @type
+              error << " of type #{@klass.fields[attr].type}"
+            end
+
+            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
+        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 #{@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
+    end
+
+    def have_field(*args)
+      HaveField.new(*args)
+    end
+    alias_method :have_fields, :have_field
+  end
+end

data/lib/matchers/have_index_for.rb

@@ -0,0 +1,63 @@
+module Mongoid
+  module Matchers
+    def have_index_for(index_key)
+      HaveIndexFor.new(index_key)
+    end
+
+    class HaveIndexFor
+      def initialize(index_key)
+        @index_key = index_key.symbolize_keys
+      end
+
+      def with_options(index_options)
+        @index_options = index_options
+        self
+      end
+
+      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},"
+        if actual_index.nil?
+          message << " found no index"
+        else
+          message << " 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}"
+        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/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)
+        fail('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
+          fail('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/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,22 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateConfirmationOfMatcher < HaveValidationMatcher
+        include WithMessage
+
+        def initialize(name)
+          super(name, :confirmation)
+        end
+
+        def with_message(message)
+          @expected_message = message
+          self
+        end
+      end
+
+      def validate_confirmation_of(field)
+        ValidateConfirmationOfMatcher.new(field)
+      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