carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/active_record/macros/validations/ensure_value_in_range_matcher.rb

@@ -0,0 +1,172 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class EnsureValueInRangeMatcher < Remarkable::Matcher::Base
+        include Remarkable::ActiveRecord::Helpers
+
+        def initialize(attribute, behavior, range, *options)
+          @attribute = attribute
+          @range     = range
+          @behavior  = behavior
+          load_options(options.extract_options!)
+        end
+        
+        def low_message(message)
+          warn "[DEPRECATION] should_ensure_value_in_range.low_message is deprecated. " <<
+               "Use should_validate_inclusion_of.message instead."
+          @options[:low_message] = message
+          self
+        end
+
+        def high_message(message)
+          warn "[DEPRECATION] should_ensure_value_in_range.high_message is deprecated. " <<
+               "Use should_validate_inclusion_of.message instead."
+          @options[:high_message] = message
+          self
+        end
+
+        # TODO Low message and High message should be deprecated (not supported by
+        # Rails API). In this while, we have to hack message.
+        def message(message)
+          @options[:high_message] = message
+          @options[:low_message]  = message
+          @options[:message]      = message
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher do
+            less_than_minimum? && accepts_minimum? && more_than_minimum? && allow_nil? &&
+            more_than_maximum? && accepts_maximum? && less_than_maximum? && allow_blank?
+          end
+        end
+
+        def description
+          "ensure #{expectation}"
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        private
+
+        def expectation
+          message = "that the #{@attribute} is #{'not ' if @behavior == :exclusion}in #{@range}"
+          message << " or is nil"   if @options[:allow_nil]
+          message << " or is blank" if @options[:allow_blank]
+          message
+        end
+
+        def less_than_minimum?
+          return true unless @behavior == :inclusion
+          return true if bad?(@range.first - 1, :low_message)
+
+          @missing = "allow #{@attribute} to be less than #{@range.first}"
+          return false
+        end
+
+        def more_than_maximum?
+          return true unless @behavior == :inclusion
+          return true if bad?(@range.last + 1, :high_message)
+          
+          @missing = "allow #{@attribute} to be more than #{@range.last}"
+          return false
+        end
+
+        def less_than_maximum?
+          return true unless @behavior == :exclusion
+          return true if bad?(@range.last - 1, :low_message)
+
+          @missing = "allow #{@attribute} to be less than #{@range.last}"
+          return false
+        end
+
+        def more_than_minimum?
+          return true unless @behavior == :exclusion
+          return true if bad?(@range.first + 1, :high_message)
+          
+          @missing = "allow #{@attribute} to be more than #{@range.first}"
+          return false
+        end
+
+        def accepts_minimum?
+          return true if boundary?(@range.first, :low_message)
+
+          @missing = create_boundary_message("allow #{@attribute} to be #{@range.first}")
+          return false
+        end
+
+        def accepts_maximum?
+          return true if boundary?(@range.last, :high_message)
+
+          @missing = create_boundary_message("allow #{@attribute} to be #{@range.last}")
+          return false
+        end
+
+        # Create a message based on the behavior (inclusion or exclusion).
+        #
+        # Let's suppose the following validation:
+        #
+        #   validate_inclusion_of :age, 18..100
+        #
+        # If eventually :age cannot be a 100, the message should be:
+        #
+        #   (not allow :age to be 100)
+        #
+        # When we have:
+        #
+        #   validate_exclusion_of :age, 18..100
+        #
+        # If eventually :age can be a 100, the message should be:
+        #
+        #   (allow :age to be 100)
+        #
+        def create_boundary_message(message)
+          if @behavior == :exclusion
+            message
+          else
+            "not " << message
+          end
+        end
+
+        def boundary?(value, message_sym)
+          if @behavior == :exclusion
+            bad?(value, message_sym)
+          else
+            good?(value, message_sym)
+          end
+        end
+
+        def load_options(options = {})
+          warn "[DEPRECATION] should_ensure_value_in_range with :low_message is deprecated. " <<
+               "Use should_validate_inclusion_of with :message instead." if options[:low_message]
+
+          warn "[DEPRECATION] should_ensure_value_in_range with :high_message is deprecated. " <<
+               "Use should_validate_inclusion_of with :message instead." if options[:high_message]
+
+          warn "[DEPRECATION] should_ensure_value_in_range is deprecated. " <<
+               "Use should_validate_inclusion_of instead." if options[:low_message].blank? && options[:high_message].blank?
+
+          @options = {
+            :low_message  => @behavior,
+            :high_message => @behavior,
+            :message      => @behavior
+          }.merge(options)
+        end
+      end
+
+
+      # TODO Deprecate this method, but not the matcher.
+      def ensure_value_in_range(attribute, range, *options) #:nodoc:
+        EnsureValueInRangeMatcher.new(attribute, :inclusion, range, *options)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/have_class_methods_matcher.rb

@@ -0,0 +1,54 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class HaveClassMethods < Remarkable::Matcher::Base
+        def initialize(*methods)
+          methods.extract_options!
+          @methods = methods
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher_for(@methods) do |method|
+            @method = method
+            have_class_method?
+          end
+        end
+
+        def description
+          "respond to class method #{@methods.to_sentence}"
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        private
+
+        def have_class_method?
+          return true if subject_class.respond_to?(@method)
+
+          @missing = "#{subject_name} does not have class method #{@method}"
+          return false
+        end
+
+        def expectation
+          "#{subject_name} to respond to class method #{@method}"
+        end
+      end
+
+      # Ensure that the given class methods are defined on the model.
+      #
+      #   it { should have_class_methods(:find, :destroy) }
+      #
+      def have_class_methods(*methods)
+        HaveClassMethods.new(*methods)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/have_instance_methods_matcher.rb

@@ -0,0 +1,54 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class HaveInstanceMethods < Remarkable::Matcher::Base
+        def initialize(*methods)
+          methods.extract_options!
+          @methods = methods
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher_for(@methods) do |method|
+            @method = method
+            have_instance_method?
+          end
+        end
+
+        def description
+          "respond to instance method #{@methods.to_sentence}"
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        private
+        
+        def have_instance_method?
+          return true if subject_class.new.respond_to?(@method)
+          
+          @missing = "#{subject_name} does not have instance method #{@method}"
+          return false
+        end
+
+        def expectation
+          "#{subject_name} to respond to instance method #{@method}"
+        end
+      end
+
+      # Ensure that the given instance methods are defined on the model.
+      #
+      #   it { should have_instance_methods(:email, :name, :name=) }
+      #
+      def have_instance_methods(*methods)
+        HaveInstanceMethods.new(*methods)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/have_named_scope_matcher.rb

@@ -0,0 +1,94 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class HaveNamedScope < Remarkable::Matcher::Base
+        def initialize(scope_call, *args)
+          @scope_opts = args.extract_options!
+          @scope_call = scope_call.to_s
+          @args       = args
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher do
+            @scope = eval("#{subject_class}.#{@scope_call}")
+            return_scope_object? && scope_itself_to_options?
+          end
+        end
+
+        def description
+          "have to scope itself to #{@scope_opts.inspect} when #{@scope_call} is called"
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+        
+        private
+        
+        def return_scope_object?
+          return true if @scope.class == ::ActiveRecord::NamedScope::Scope
+          
+          @missing = "#{@scope_call} didn't return a scope object"
+          return false
+        end
+        
+        def scope_itself_to_options?
+          return true if @scope_opts.empty?
+          return true if @scope.proxy_options == @scope_opts
+          
+          @missing = "#{subject_name} didn't scope itself to #{@scope_opts.inspect}"
+          return false
+        end
+        
+        def expectation
+          "#{subject_name} have to scope itself to #{@scope_opts.inspect} when #{@scope_call} is called"
+        end
+      end
+
+      # Ensures that the model has a method named scope_name that returns a NamedScope object with the
+      # proxy options set to the options you supply.  scope_name can be either a symbol, or a method
+      # call which will be evaled against the model.  The eval'd method call has access to all the same
+      # instance variables that a should statement would.
+      #
+      # Options: Any of the options that the named scope would pass on to find.
+      #
+      # Example:
+      # 
+      #   it { should have_named_scope(:visible, :conditions => {:visible => true}) }
+      #
+      # Passes for
+      #
+      #   named_scope :visible, :conditions => {:visible => true}
+      #
+      # Or for
+      #
+      #   def self.visible
+      #     scoped(:conditions => {:visible => true})
+      #   end
+      #
+      # You can test lambdas or methods that return ActiveRecord#scoped calls:
+      #
+      #   it { should have_named_scope('recent(5)', :limit => 5) }
+      #   it { should have_named_scope('recent(1)', :limit => 1) }
+      #
+      # Passes for
+      #   named_scope :recent, lambda {|c| {:limit => c}}
+      #
+      # Or for
+      #
+      #   def self.recent(c)
+      #     scoped(:limit => c)
+      #   end
+      #
+      def have_named_scope(scope_call, *args)
+        HaveNamedScope.new(scope_call, *args)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/have_readonly_attributes_matcher.rb

@@ -0,0 +1,48 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class HaveReadonlyAttributes < Remarkable::Matcher::Base
+        def initialize(*attributes)
+          attributes.extract_options!
+          @attributes = attributes
+        end
+
+        def matches?(subject)
+          @subject = subject
+          assert_matcher_for(@attributes) do |attribute|
+            @attribute = attribute
+            attribute_readonly?
+          end
+        end
+
+        def description
+          "make #{@attributes.to_sentence} read-only"
+        end
+
+        private
+
+        def attribute_readonly?
+          attribute = @attribute.to_sym
+          readonly = subject_class.readonly_attributes || []
+          return true if readonly.include?(attribute.to_s)
+
+          @missing = (readonly.empty? ? "#{subject_class} attribute #{attribute} is not read-only" :
+                                        "#{subject_class} is making #{readonly.to_a.to_sentence} read-only, but not #{attribute}.")
+          return false
+        end
+        
+        def expectation
+          "that #{@attribute} cann be changed once the record has been created"
+        end
+      end
+
+      # Ensures that the attribute cannot be changed once the record has been created.
+      #
+      #   it { should have_readonly_attributes(:password, :admin_flag) }
+      #
+      def have_readonly_attributes(*attributes)
+        HaveReadonlyAttributes.new(*attributes)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/protect_attributes_matcher.rb

@@ -0,0 +1,51 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class ProtectAttributes < Remarkable::Matcher::Base
+        def initialize(*attributes)
+          attributes.extract_options!
+          @attributes = attributes
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher_for(@attributes) do |attribute|
+            @attribute = attribute
+            protect_from_mass_updates?
+          end
+        end
+
+        def description
+          "protect #{@attributes.to_sentence} from mass updates"
+        end
+        
+        private
+        
+        def protect_from_mass_updates?
+          attribute  = @attribute.to_sym
+          protected  = subject_class.protected_attributes || []
+          accessible = subject_class.accessible_attributes || []
+
+          return true if protected.include?(attribute.to_s)
+          return true if !accessible.empty? && !accessible.include?(attribute.to_s)
+
+          @missing = accessible.empty? ? "#{subject_class} is protecting #{protected.to_a.to_sentence}, but not #{attribute}." :
+                                         "#{subject_class} has made #{attribute} accessible"
+          return false
+        end
+        
+        def expectation
+          "that #{@attribute} cannot be set on mass update"
+        end
+      end
+
+      # TODO Deprecate this method and the matcher.
+      def protect_attributes(*attributes) #:nodoc:
+        warn "[DEPRECATION] should_protect_attributes is deprecated. " <<
+             "Use should_not_allow_mass_assignment_of instead."
+        ProtectAttributes.new(*attributes)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/validate_acceptance_of_matcher.rb

@@ -0,0 +1,79 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class ValidateAcceptanceOfMatcher < Remarkable::Matcher::Base
+        include Remarkable::ActiveRecord::Helpers
+
+        undef_method :allow_blank, :allow_blank?
+
+        arguments  :attributes
+        optional   :accept
+        assertions :allow_nil?, :require_accepted?, :accept_is_valid?
+
+        def description
+          message = "require #{@attributes.to_sentence} to be accepted"
+          message << " or nil" if @options[:nil]
+          message
+        end
+
+        private
+
+        def require_accepted?
+          return true if bad?(false)
+
+          @missing = "not require #{@attribute} to be accepted"
+          return false
+        end
+
+        def accept_is_valid?
+          return true unless @options.key? :accept
+          return true if good?(@options[:accept])
+
+          @missing = "is not accepted when #{@attribute} is #{@options[:accept].inspect}"
+          false
+        end
+
+        # Receives a Hash
+        def load_options(options = {})
+          @options = {
+            :message => :accepted
+          }.merge(options)
+        end
+
+        def expectation
+          message = "that the #{subject_name} can be saved if #{@attribute} is accepted"
+          message << " or nil" if @options[:allow_nil]
+          message
+        end
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:accept</tt> - the expected value to be accepted.
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.accepted')</tt>
+      #
+      # Example:
+      #   it { should validate_acceptance_of(:eula, :terms) }
+      #   it { should validate_acceptance_of(:eula, :terms, :accept => true) }
+      #
+      def validate_acceptance_of(*attributes)
+        ValidateAcceptanceOfMatcher.new(*attributes)
+      end
+
+      # TODO Deprecate this method.
+      def require_acceptance_of(*attributes) #:nodoc:
+        warn "[DEPRECATION] should_require_acceptance_of is deprecated. " <<
+             "Use should_validate_acceptance_of instead."
+        ValidateAcceptanceOfMatcher.new(*attributes)
+      end
+
+    end
+  end
+end