carlosbrando-remarkable 0.0.99

data/lib/remarkable/controller/macros/assign_to.rb

@@ -0,0 +1,110 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a test asserting that the controller assigned to
+      # each of the named instance variable(s).
+      #
+      # Options:
+      # * <tt>:class</tt> - The expected class of the instance variable being checked.
+      # * <tt>:equals</tt> - A string which is evaluated and compared for equality with
+      # the instance variable being checked.
+      #
+      # Example:
+      #
+      #   it { should assign_to(:user, :posts) }
+      #   it { should assign_to(:user, :class => User) }
+      #   it { should assign_to(:user, :equals => '@user') }
+      # 
+      def assign_to(*names)
+        opts = names.extract_options!
+        test_name = "assign @#{names.to_sentence}"
+        test_name << " as class #{opts[:class]}" if opts[:class]
+        test_name << " which is equal to #{opts[:equals]}" if opts[:equals]
+
+        simple_matcher test_name do |controller, matcher|
+          ret = true
+          names.each do |name|
+            assigned_value = assigns(name.to_sym)
+
+            unless assigned_value
+              ret = false
+              break
+            end
+
+            if opts[:class]
+              unless assigned_value.kind_of?(opts[:class])
+                ret = false
+                break
+              end
+            end
+
+            if opts[:equals]
+              instantiate_variables_from_assigns do
+                expected_value = eval(opts[:equals], self.send(:binding), __FILE__, __LINE__)
+                unless assigned_value == expected_value
+                  ret = false
+                  break
+                end
+              end
+            end
+          end
+
+          ret
+        end
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that the controller assigned to
+      # each of the named instance variable(s).
+      #
+      # Options:
+      # * <tt>:class</tt> - The expected class of the instance variable being checked.
+      # * <tt>:equals</tt> - A string which is evaluated and compared for equality with
+      # the instance variable being checked.
+      #
+      # Example:
+      #
+      #   should_assign_to :user, :posts
+      #   should_assign_to :user, :class => User
+      #   should_assign_to :user, :equals => '@user'
+      # 
+      def should_assign_to(*names)
+        opts = names.extract_options!
+        names.each do |name|
+          test_name = "should assign @#{name}"
+          test_name << " as class #{opts[:class]}" if opts[:class]
+          test_name << " which is equal to #{opts[:equals]}" if opts[:equals]
+          it test_name do
+            assigned_value = assigns(name.to_sym)
+            assigned_value.should_not be_nil
+            assigned_value.should be_a_kind_of(opts[:class]) if opts[:class]
+            if opts[:equals]
+              instantiate_variables_from_assigns do
+                expected_value = eval(opts[:equals], self.send(:binding), __FILE__, __LINE__)
+                assigned_value.should == expected_value
+              end
+            end
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the controller did not assign to
+      # any of the named instance variable(s).
+      #
+      # Example:
+      #
+      #   should_not_assign_to :user, :posts
+      # 
+      def should_not_assign_to(*names)
+        names.each do |name|
+          it "should not assign to @#{name}" do
+            assigns(name.to_sym).should be_nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/remarkable/controller/macros/filter_params.rb

@@ -0,0 +1,52 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a test asserting that filter_parameter_logging
+      # is set for the specified keys
+      #
+      # Example:
+      #
+      #   should_filter_params :password, :ssn
+      # 
+      def filter_params(*keys)
+        simple_matcher "filter #{keys.to_sentence}" do
+          ret = true
+          keys.each do |key|
+            if controller.respond_to?(:filter_parameters)
+              filtered = controller.send(:filter_parameters, {key.to_s => key.to_s})
+              unless filtered[key.to_s] == '[FILTERED]'
+                ret = false
+                break  
+              end
+            else
+              ret = false
+              break
+            end
+          end
+          ret
+        end
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that filter_parameter_logging
+      # is set for the specified keys
+      #
+      # Example:
+      #
+      #   should_filter_params :password, :ssn
+      # 
+      def should_filter_params(*keys)
+        keys.each do |key|
+          it "should filter #{key}" do
+            controller.should respond_to(:filter_parameters)
+            filtered = controller.send(:filter_parameters, {key.to_s => key.to_s})
+            filtered[key.to_s].should == '[FILTERED]'
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/controller/macros/redirect_to.rb

@@ -0,0 +1,24 @@
+module Remarkable
+  module Syntax
+    
+    module Shoulda
+      # Macro that creates a test asserting that the controller returned a redirect to the given path.
+      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
+      # set by the controller are available to the evaled string.
+      # Example:
+      #
+      #   should_redirect_to '"/"'
+      #   should_redirect_to "user_url(@user)"
+      #   should_redirect_to "users_url"
+      # 
+      def should_redirect_to(url)
+        it "should redirect to #{url.inspect}" do
+          instantiate_variables_from_assigns do
+            response.should redirect_to(eval(url, self.send(:binding), __FILE__, __LINE__))
+          end
+        end
+      end
+    end
+  
+  end
+end

data/lib/remarkable/controller/macros/render_a_form.rb

@@ -0,0 +1,23 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a test asserting that the rendered view contains a <form> element.
+      def render_a_form
+        simple_matcher "should display a form" do |controller|
+          controller.response.should have_tag("form")
+        end
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that the rendered view contains a <form> element.
+      def should_render_a_form
+        it "should display a form" do
+          response.should have_tag("form")
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/controller/macros/render_template.rb

@@ -0,0 +1,18 @@
+module Remarkable
+  module Syntax
+
+    module Shoulda
+      # Macro that creates a test asserting that the controller rendered the given template.
+      # Example:
+      #
+      #   should_render_template :new
+      # 
+      def should_render_template(template)
+        it "should render template #{template.inspect}" do
+          response.should render_template(template.to_s)
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/controller/macros/render_with_layout.rb

@@ -0,0 +1,61 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a test asserting that the controller rendered with the given layout.
+      # Example:
+      #
+      #   it { should render_with_layout('special') }
+      #   it { should render_with_layout(:special) }
+      # 
+      def render_with_layout(expected_layout = 'application')
+        if expected_layout
+          simple_matcher "render with #{expected_layout.inspect} layout" do |controller|
+            response_layout = response.layout.blank? ? "" : response.layout.split('/').last
+            response_layout.should == expected_layout.to_s
+          end
+        else
+          simple_matcher "render without layout" do
+            response.layout.should be_nil
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the controller rendered without a layout.
+      # Same as @it { should render_with_layout(false) }@
+      def render_without_layout
+        simple_matcher "render without layout" do |controller|
+          controller.should render_with_layout(nil)
+        end
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that the controller rendered with the given layout.
+      # Example:
+      #
+      #   should_render_with_layout 'special'
+      #   should_render_with_layout :special
+      # 
+      def should_render_with_layout(expected_layout = 'application')
+        if expected_layout
+          it "should render with #{expected_layout.inspect} layout" do
+            response_layout = response.layout.blank? ? "" : response.layout.split('/').last
+            response_layout.should == expected_layout.to_s
+          end
+        else
+          it "should render without layout" do
+            response.layout.should be_nil
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the controller rendered without a layout.
+      # Same as @should_render_with_layout false@
+      def should_render_without_layout
+        should_render_with_layout nil
+      end
+    end
+
+  end
+end

data/lib/remarkable/controller/macros/respond_with.rb

@@ -0,0 +1,86 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class RespondWith
+        include Remarkable::Private
+
+        def initialize(response, type)
+          @response = response
+          @type = type
+        end
+
+        def matches?(controller)
+          @controller = controller
+
+          begin
+            if [ :success, :missing, :redirect, :error ].include?(@type) && @response.send("#{@type}?")
+            elsif @type.is_a?(Fixnum) && @response.response_code == @type
+            elsif @type.is_a?(Symbol) && @response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@type]
+            else
+              if @response.error?
+                exception = @response.template.instance_variable_get(:@exception)
+                exception_message = exception && exception.message
+                fail "Expected response to be a #{@type}, but was #{@response.response_code}\n#{exception_message.to_s}"
+              else
+                fail "Expected response to be a #{@type}, but was #{@response.response_code}"
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "respond with #{@type}"
+        end
+
+        def failure_message
+          @failure_message || "expected respond with #{@type}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected not respond with #{@type}, but it did"
+        end
+      end
+
+      # Macro that creates a test asserting that the controller responded with a 'response' status code.
+      # Example:
+      #
+      #   it { should respond_with(:success) }
+      #
+      def respond_with(type)
+        Remarkable::Syntax::RSpec::RespondWith.new(response, type)
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that the controller responded with a 'response' status code.
+      # Example:
+      #
+      #   should_respond_with :success
+      # 
+      def should_respond_with(type)
+        it "should respond with #{type}" do
+          clean_backtrace do
+            if [ :success, :missing, :redirect, :error ].include?(type) && response.send("#{type}?")
+            elsif type.is_a?(Fixnum) && response.response_code == type
+            elsif type.is_a?(Symbol) && response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
+            else
+              if response.error?
+                exception = response.template.instance_variable_get(:@exception)
+                exception_message = exception && exception.message
+                Spec::Expectations.fail_with "Expected response to be a #{type}, but was #{response.response_code}\n#{exception_message.to_s}"
+              else
+                Spec::Expectations.fail_with "Expected response to be a #{type}, but was #{response.response_code}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/controller/macros/respond_with_content_type.rb

@@ -0,0 +1,45 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a test asserting that the response content type was 'content_type'.
+      # Example:
+      #
+      #   should_respond_with_content_type 'application/rss+xml'
+      #   should_respond_with_content_type :rss
+      #   should_respond_with_content_type /rss/
+      # 
+      def respond_with_content_type(content_type)
+        simple_matcher "respond with content type of #{content_type}" do
+          content_type = Mime::EXTENSION_LOOKUP[content_type.to_s].to_s if content_type.is_a? Symbol
+          if content_type.is_a? Regexp
+            response.content_type =~ content_type
+          else
+            response.content_type == content_type
+          end
+        end
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that the response content type was 'content_type'.
+      # Example:
+      #
+      #   should_respond_with_content_type 'application/rss+xml'
+      #   should_respond_with_content_type :rss
+      #   should_respond_with_content_type /rss/
+      # 
+      def should_respond_with_content_type(content_type)
+        it "should respond with content type of #{content_type}" do
+          content_type = Mime::EXTENSION_LOOKUP[content_type.to_s].to_s if content_type.is_a? Symbol
+          if content_type.is_a? Regexp
+            response.content_type.should match(content_type)
+          else
+            response.content_type.should == content_type
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/remarkable/controller/macros/return_from_session.rb

@@ -0,0 +1,45 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a test asserting that a value returned from the session is correct.
+      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
+      # set by the controller are available to the evaled string.
+      # Example:
+      #
+      #   should_return_from_session :user_id, '@user.id'
+      #   should_return_from_session :message, '"Free stuff"'
+      # 
+      def return_from_session(key, expected)
+        simple_matcher "return the correct value from the session for key #{key}" do
+          ret = true
+          instantiate_variables_from_assigns do
+            expected_value = eval(expected, self.send(:binding), __FILE__, __LINE__)
+            ret = (session[key] == expected_value)
+          end
+          ret
+        end
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that a value returned from the session is correct.
+      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
+      # set by the controller are available to the evaled string.
+      # Example:
+      #
+      #   should_return_from_session :user_id, '@user.id'
+      #   should_return_from_session :message, '"Free stuff"'
+      # 
+      def should_return_from_session(key, expected)
+        it "should return the correct value from the session for key #{key}" do
+          instantiate_variables_from_assigns do
+            expected_value = eval(expected, self.send(:binding), __FILE__, __LINE__)
+            session[key].should == expected_value
+          end
+        end
+      end
+    end
+
+  end
+end