mongoid-minitest 0.1.5 → 1.0.0

data/lib/matchers/helpers.rb

@@ -1,13 +0,0 @@
-module Mongoid
-  module Matchers
-    module Helpers
-      def to_sentence ary
-        ary.collect(&:inspect).to_sentence
-      end
-
-      def class_of subject
-        subject.is_a?(Class) ? subject : subject.class
-      end
-    end
-  end
-end

data/lib/matchers/validations/acceptance.rb

@@ -1,47 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class ValidateAcceptanceMatcher < HaveValidationMatcher
-        def initialize(field)
-          super(field, :acceptance)
-        end
-
-        def accept_with(value)
-          @accepted = value
-          self
-        end
-
-        def matches?(subject)
-          return false unless @result = super(subject)
-          
-          check_accepted_value if @accepted
-
-          @result
-        end
-
-        def description
-          desc = []
-          desc << " accept with #{@accepted.inspect}" if @accepted
-          super << desc.to_sentence
-        end
-
-        private
-
-        def check_accepted_value
-          actual = @validator.options[:accept]
-
-          if actual == @accepted
-            @positive_message << " accept with #{actual.inspect}"
-          else
-            @negative_message << " accept with #{actual.inspect}"
-            @result = false
-          end
-        end
-      end
-
-      def validate_acceptance_of(field)
-        ValidateAcceptanceMatcher.new(field)
-      end
-    end
-  end
-end

data/lib/matchers/validations/associated.rb

@@ -1,19 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class ValidateAssociated < HaveValidationMatcher
-        def initialize(association_name)
-          super(association_name, :associated)
-        end
-
-        def description
-          "validate associated #{@field.inspect}"
-        end
-      end
-
-      def validate_associated(association_name)
-        ValidateAssociated.new(association_name)
-      end
-    end
-  end
-end

data/lib/matchers/validations/confirmation.rb

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

data/lib/matchers/validations/exclusion.rb

@@ -1,52 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class ValidateExclusionMatcher < HaveValidationMatcher
-        def initialize(field)
-          super(field, :exclusion)
-        end
-
-        def to_not_allow(*values)
-          @not_allowed_values = (values.length > 1) ? values.flatten : values[0]
-          self
-        end
-
-        def matches?(subject)
-          return false unless result = super(subject)
-
-          if Array === @not_allowed_values
-            allowed_values = @not_allowed_values - @validator.options[:in].to_a
-            if allowed_values.empty?
-              @positive_message << ' not allowing all values mentioned'
-            else
-              @negative_message << ' allowing the values:'
-              @negative_message << " #{to_sentence(allowed_values)}"
-              result = false
-            end
-          elsif @not_allowed_values
-            if @not_allowed_values == @validator.options[:in]
-              @positive_message << " not allowing values in #{@not_allowed_values.inspect}"
-            else
-              @negative_message << " not allowing values in #{@validator.options[:in].inspect}"
-              result = false
-            end
-          end
-
-          result
-        end
-
-        def description
-          if Array === @not_allowed_values
-            super << " not allowing the values: #{to_sentence(@not_allowed_values)}"
-          elsif @not_allowed_values
-            super << " not allowing the values in #{@not_allowed_values.inspect}"
-          end
-        end
-      end
-
-      def validate_exclusion_of(field)
-        ValidateExclusionMatcher.new(field)
-      end
-    end
-  end
-end

data/lib/matchers/validations/format.rb

@@ -1,65 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class ValidateFormatMatcher < HaveValidationMatcher
-        def initialize field
-          super field, :format
-        end
-
-        def to_allow valid_value
-          @valid = valid_value
-          self
-        end
-
-        def to_not_allow invalid_value
-          @invalid = invalid_value
-          self
-        end
-
-        def matches? subject
-          return false unless @result = super(subject)
-
-          check_valid_value   if @valid
-          check_invalid_value if @invalid
-
-          @result
-        end
-
-        def description
-          desc = []
-          desc << " allowing the value #{@valid.inspect}" if @valid
-          desc << " not allowing the value #{@invalid.inspect}" if @invalid
-          super << desc.to_sentence
-        end
-
-        private
-
-        def check_valid_value
-          if format == @valid || format =~ @valid
-            @positive_message << " with #{@valid.inspect} as a valid value"
-          else
-            @negative_message << " with #{@valid.inspect} as an invalid value"
-            @result = false
-          end
-        end
-
-        def check_invalid_value
-          if format !~ @invalid
-            @positive_message << " with #{@invalid.inspect} as a invalid value"
-          else
-            @negative_message << " with #{@invalid.inspect} as a valid value"
-            @result = false
-          end
-        end
-
-        def format
-          @validator.options[:with]
-        end
-      end
-
-      def validate_format_of field
-        ValidateFormatMatcher.new field
-      end
-    end
-  end
-end

data/lib/matchers/validations/inclusion.rb

@@ -1,52 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class ValidateInclusionMatcher < HaveValidationMatcher
-        def initialize(field)
-          super(field, :inclusion)
-        end
-
-        def to_allow(*values)
-          @allowed_values = (values.length > 1) ? values.flatten : values[0]
-          self
-        end
-
-        def matches?(subject)
-          return false unless result = super(subject)
-
-          if Array === @allowed_values
-            not_allowed_values = @allowed_values - @validator.options[:in].to_a
-            if not_allowed_values.empty?
-              @positive_message << ' allowing all values mentioned'
-            else
-              @negative_message << ' not allowing the following the values:'
-              @negative_message << " #{not_allowed_values.inspect}"
-              result = false
-            end
-          elsif @allowed_values
-            if @allowed_values == @validator.options[:in]
-              @positive_message << " allowing values in #{@allowed_values.inspect}"
-            else
-              @negative_message << " allowing values in #{@validator.options[:in].inspect}"
-              result = false
-            end
-          end
-
-          result
-        end
-
-        def description
-          if Array === @allowed_values
-            super << " allowing the values: #{to_sentence(@allowed_values)}"
-          elsif @allowed_values
-            super << " allowing the values in #{@allowed_values.inspect}"
-          end
-        end
-      end
-
-      def validate_inclusion_of(field)
-        ValidateInclusionMatcher.new(field)
-      end
-    end
-  end
-end

data/lib/matchers/validations/length.rb

@@ -1,86 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class ValidateLengthMatcher < HaveValidationMatcher
-        def initialize(field)
-          super(field, :length)
-        end
-
-        def with_minimum(value)
-          @minimum = value
-          self
-        end
-        alias :with_min :with_minimum
-
-        def with_maximum(value)
-          @maximum = value
-          self
-        end
-        alias :with_max :with_maximum
-
-        def within(value)
-          @within = value
-          self
-        end
-        alias :in :within
-
-        def matches?(subject)
-          return false unless @result = super(subject)
-
-          check_minimum if @minimum
-          check_maximum if @maximum
-          check_range   if @within
-
-          @result
-        end
-
-        def description
-          desc = []
-          desc << " with minimum #{@minimum}" if @minimum
-          desc << " with maximum #{@maximum}" if @maximum
-          desc << " within range #{@within}"  if @within
-          super << desc.to_sentence
-        end
-
-        private
-
-        def check_minimum
-          actual = @validator.options[:minimum]
-          if actual == @minimum
-            @positive_message << " with minimum of #{actual}"
-          else
-            @negative_message << " with minimum of #{actual}"
-            @result = false
-          end
-        end
-
-        def check_maximum
-          actual = @validator.options[:maximum]
-          if actual == @maximum
-            @positive_message << " with maximum of #{actual}"
-          else
-            @negative_message << " with maximum of #{actual}"
-            @result = false
-          end
-        end
-
-        def check_range
-          min, max = [@within.min, @within.max]
-          actual_min = @validator.options[:minimum]
-          actual_max = @validator.options[:maximum]
-
-          if actual_min == min && actual_max == max
-            @positive_message << " with range #{@within}"
-          else
-            @negative_message << " with range #{actual_min..actual_max}"
-            @result = false
-          end
-        end
-      end
-
-      def validate_length_of(field)
-        ValidateLengthMatcher.new(field)
-      end
-    end
-  end
-end

data/lib/matchers/validations/presence.rb

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

data/lib/matchers/validations/uniqueness.rb

@@ -1,64 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class ValidateUniquenessMatcher < HaveValidationMatcher
-        def initialize(field)
-          super(field, :uniqueness)
-        end
-
-        def case_insensitive
-          @case_insensitive = true
-          self
-        end
-
-        def scoped_to(*scope)
-          @scope = [scope].flatten.map(&:to_s)
-          self
-        end
-
-        def matches?(subject)
-          return false unless @result = super(subject)
-
-          check_scope if @scope
-          check_case_sensivity if @case_insensitive
-
-          @result
-        end
-
-        def description
-          desc = []
-          desc << " scoped to #{to_sentence(@scope)}" if @scope
-          desc << ' allowing case insensitive values' if @case_insensitive
-          super << desc.to_sentence
-        end
-
-        private
-
-        def check_scope
-          actual_scope = [@validator.options[:scope]].flatten.map(&:to_s)
-          message = " scoped to #{to_sentence(actual_scope)}"
-
-          if actual_scope == @scope
-            @positive_message << message
-          else
-            @negative_message << message
-            @result = false
-          end
-        end
-
-        def check_case_sensivity
-          if @validator.options[:case_sensitive] == false
-            @positive_message << ' with case insensitive values'
-          else
-            @negative_message << ' without case insensitive values'
-            @result = false
-          end
-        end
-      end
-
-      def validate_uniqueness_of(field)
-        ValidateUniquenessMatcher.new(field)
-      end
-    end
-  end
-end

data/lib/matchers/validations/validations.rb

@@ -1,91 +0,0 @@
-module Mongoid
-  module Matchers
-    module Validations
-      class HaveValidationMatcher < Matcher
-        def initialize(field, validation_type)
-          @field = field.to_s
-          @type = validation_type.to_s
-        end
-
-        def with_message(expected_message)
-          @expected_message = expected_message
-          self
-        end
-
-        def on(*contexts)
-          @expected_on = clean_contexts(contexts)
-          self
-        end
-
-        def matches?(subject)
-          @klass     = class_of(subject)
-          @validator = detect_validator
-          @result    = true
-
-          check_validator
-          check_message if @expected_message
-          check_on if @expected_on
-
-          @result
-        end
-
-        def failure_message
-          "#{@klass} to #{description}; instead got #{@negative_message}"
-        end
-
-        def negative_failure_message
-          "#{@klass} to not #{description}; instead got #{@positive_message}"
-        end
-
-        def description
-          desc = "validate #{@type.inspect} of #{@field.inspect}"
-          desc << " with message: #{@expected_message.inspect}" if @expected_message
-          desc << " on #{@expected_on.empty? ? 'all actions' : to_sentence(@expected_on)}" if @expected_on
-
-          desc
-        end
-
-        private
-
-        # Make sure contexts is always an array + normalize AR 2.x and AR 3.x differences
-        def clean_contexts(contexts)
-          [contexts].flatten.reject{|ctx| ctx == :save}.compact
-        end
-
-        def check_validator
-          if @validator
-            @negative_message = "#{@type.inspect} validator for #{@field.inspect}"
-            @positive_message = "#{@type.inspect} validator for #{@field.inspect}"
-          else
-            @negative_message = "no #{@type.inspect} validator for #{@field.inspect}"
-            @result = false
-          end
-        end
-
-        def check_message
-          error_message = @validator.options[:message]
-          if @expected_message == error_message
-            @positive_message << " with message: #{error_message.inspect}"
-          else
-            @negative_message << " with message: #{error_message.inspect}"
-            @result = false
-          end
-        end
-
-        def check_on
-          on = clean_contexts(@validator.options[:on])
-          if on.sort == @expected_on.sort
-            @positive_message << " on #{on.empty? ? 'all actions' : to_sentence(on)}"
-          else
-            @negative_message << " on #{on.empty? ? 'all actions' : to_sentence(on)}"
-            @result = false
-          end
-        end
-
-        def detect_validator
-          @klass.validators_on(@field).detect { |v| v.kind.to_s == @type }
-        end
-      end
-    end
-  end
-end