carlosbrando-remarkable 0.0.99

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

@@ -0,0 +1,74 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveClassMethods
+        include Remarkable::Private
+        
+        def initialize(*methods)
+          get_options!(methods)
+          @methods = methods
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @methods.each do |method|
+              unless klass.respond_to?(method)
+                fail "#{klass.name} does not have class method #{method}"
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "respond to class method #{pretty_method_names}"
+        end
+
+        def failure_message
+          @failure_message || "expected that #{pretty_method_names} #{@methods.size > 1 ? "is" : "are"} defined on #{@klass.name}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected that #{pretty_method_names} #{@methods.size > 1 ? "aren't" : "isn't"} defined on #{@klass.name}, but it did"
+        end
+
+        def pretty_method_names
+          @methods.map { |m| "##{m}" }.to_sentence
+        end
+      end
+
+      # Ensure that the given class methods are defined on the model.
+      #
+      #   it { User.should have_class_methods(:find, :destroy) }
+      #
+      def have_class_methods(*methods)
+        Remarkable::Syntax::RSpec::HaveClassMethods.new(*methods)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the given class methods are defined on the model.
+      #
+      #   should_have_class_methods :find, :destroy
+      #
+      def should_have_class_methods(*methods)
+        get_options!(methods)
+        klass = model_class
+        methods.each do |method|
+          it "should respond to class method ##{method}" do
+            unless klass.respond_to?(method)
+              fail_with "#{klass.name} does not have class method #{method}"
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,74 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveInstanceMethods
+        include Remarkable::Private
+        
+        def initialize(*methods)
+          get_options!(methods)
+          @methods = methods
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @methods.each do |method|
+              unless klass.new.respond_to?(method)
+                fail "#{klass.name} does not have instance method #{method}"
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "respond to instance method #{pretty_method_names}"
+        end
+
+        def failure_message
+          @failure_message || "expected that #{pretty_method_names} #{@methods.size > 1 ? "is" : "are"} defined on #{@klass.name}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected that #{pretty_method_names} #{@methods.size > 1 ? "aren't" : "isn't"} defined on #{@klass.name}, but it did"
+        end
+
+        def pretty_method_names
+          @methods.map { |m| "##{m}" }.to_sentence
+        end
+      end
+
+      # Ensure that the given instance methods are defined on the model.
+      #
+      #   it { User.should have_instance_methods(:email, :name, :name=) }
+      #
+      def have_instance_methods(*methods)
+        Remarkable::Syntax::RSpec::HaveInstanceMethods.new(*methods)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the given instance methods are defined on the model.
+      #
+      #   should_have_instance_methods :email, :name, :name=
+      #
+      def should_have_instance_methods(*methods)
+        get_options!(methods)
+        klass = model_class
+        methods.each do |method|
+          it "should respond to instance method ##{method}" do
+            unless klass.new.respond_to?(method)
+              fail_with "#{klass.name} does not have instance method #{method}"
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,148 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveNamedScope
+        def initialize(scope_call, *args)
+          @scope_opts = args.extract_options!
+          @scope_call = scope_call.to_s
+          @args       = args
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            scope = eval("#{klass}.#{@scope_call}")
+
+            unless scope.class == ::ActiveRecord::NamedScope::Scope
+              fail "#{@scope_call} didn't return a scope object"
+            end
+
+            unless @scope_opts.empty? 
+              unless scope.proxy_options == @scope_opts
+                fail "#{klass.name} didn't scope itself to #{@scope_opts.inspect}"
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "have to scope itself to #{@scope_opts.inspect} when #{@scope_call} is called"
+        end
+
+        def failure_message
+          @failure_message || "expected that #{klass.name} has a method named #{@scope_call} that returns a NamedScope object with the proxy options set to the options you supply, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected that #{klass.name} hasn't a method named #{@scope_call} that returns a NamedScope object with the proxy options set to the options you supply, but it did"
+        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 { User.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 { User.should have_named_scope('recent(5)', :limit => 5) }
+      #   it { User.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)
+        Remarkable::Syntax::RSpec::HaveNamedScope.new(scope_call, *args)
+      end
+    end
+
+    module Shoulda
+      # 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:
+      #
+      #   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:
+      #
+      #   should_have_named_scope 'recent(5)', :limit => 5
+      #   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 should_have_named_scope(scope_call, *args)
+        klass = model_class
+        scope_opts = args.extract_options!
+        scope_call = scope_call.to_s
+
+        describe scope_call do
+          before(:each) do
+            @scope = eval("#{klass}.#{scope_call}")
+          end
+          
+          it "should return a scope object" do
+            @scope.class.should == ::ActiveRecord::NamedScope::Scope
+          end
+
+          unless scope_opts.empty?
+            it "should scope itself to #{scope_opts.inspect}" do
+              @scope.proxy_options.should == scope_opts
+            end
+          end
+        end
+      end
+      
+    end
+
+  end
+end

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

@@ -0,0 +1,81 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveReadonlyAttributes
+        include Remarkable::Private
+        
+        def initialize(*attributes)
+          get_options!(attributes)
+          @attributes = attributes
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @attributes.each do |attribute|
+              attribute = attribute.to_sym
+              readonly = klass.readonly_attributes || []
+
+              unless readonly.include?(attribute.to_s)
+                fail readonly.empty? ?
+                "#{klass} attribute #{attribute} is not read-only" :
+                "#{klass} is making #{readonly.to_a.to_sentence} read-only, but not #{attribute}"
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "make #{@attributes.to_sentence} read-only"
+        end
+
+        def failure_message
+          @failure_message || "expected that #{@attributes.to_sentence} cannot be changed once the record has been created, but it did"
+        end
+
+        def negative_failure_message
+          "expected that #{@attributes.to_sentence} cann be changed once the record has been created, but it didn't"
+        end
+      end
+
+      # Ensures that the attribute cannot be changed once the record has been created.
+      #
+      #   it { User.should have_readonly_attributes(:password, :admin_flag) }
+      #
+      def have_readonly_attributes(*attributes)
+        Remarkable::Syntax::RSpec::HaveReadonlyAttributes.new(*attributes)
+      end
+    end
+
+    module Shoulda
+      # Ensures that the attribute cannot be changed once the record has been created.
+      #
+      #   should_have_readonly_attributes :password, :admin_flag
+      #
+      def should_have_readonly_attributes(*attributes)
+        get_options!(attributes)
+        klass = model_class
+
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          it "should make #{attribute} read-only" do
+            readonly = klass.readonly_attributes || []
+
+            unless readonly.include?(attribute.to_s)
+              fail_with(readonly.empty? ?
+                        "#{klass} attribute #{attribute} is not read-only" :
+                        "#{klass} is making #{readonly.to_a.to_sentence} read-only, but not #{attribute}.")
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,89 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class OnlyAllowNumericValuesFor
+        include Remarkable::Private
+        
+        def initialize(*attributes)
+          @message = get_options!(attributes, :message)
+          @message ||= default_error_message(:not_a_number)
+
+          @attributes = attributes
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @attributes.each do |attribute|
+              attribute = attribute.to_sym
+              return false unless assert_bad_value(klass, attribute, "abcd", @message)
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "only allow numeric values for #{@attributes.to_sentence}"
+        end
+
+        def failure_message
+          "expected only numeric values for #{@attributes.to_sentence}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected not only numeric values for #{@attributes.to_sentence}, but it did"
+        end
+      end
+
+      # Ensure that the attribute is numeric
+      #
+      # 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>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
+      #
+      # Example:
+      #   it { User.should only_allow_numeric_values_for(:age) }
+      #
+      def only_allow_numeric_values_for(*attributes)
+        Remarkable::Syntax::RSpec::OnlyAllowNumericValuesFor.new(*attributes)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the attribute is numeric
+      #
+      # 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>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
+      #
+      # Example:
+      #   should_only_allow_numeric_values_for :age
+      #
+      def should_only_allow_numeric_values_for(*attributes)
+        message = get_options!(attributes, :message)
+        message ||= default_error_message(:not_a_number)
+        klass = model_class
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          it "should only allow numeric values for #{attribute}" do
+            assert_bad_value(klass, attribute, "abcd", message).should be_true
+          end
+        end
+      end
+    end
+
+  end
+end