carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/controller/README.markdown

@@ -0,0 +1,147 @@
+h1. Controller macros
+
+For each example below, we will show you the Rspec way and in the Macro (Shoulda) way. Choose the one that pleases you the most. :)
+
+h2. assign_to
+
+Macro that creates a test asserting that the controller assigned to each of the named instance variable(s).
+
+Options:
+
+    * :class - The expected class of the instance variable being checked.
+    * :equals - A string which is evaluated and compared for equality with the instance variable being checked.
+
+Example:
+
+<pre><code>  should_assign_to :user, :posts
+  should_assign_to :user, :class => User
+  should_assign_to :user, :equals => '@user'
+  should_not_assign_to :user, :posts
+
+  it { should assign_to(:user, :posts) }
+  it { should assign_to(:user, :class => User) }
+  it { should assign_to(:user, :equals => '@user') }
+  it { should_not assign_to(:user, :posts) }</code></pre>
+
+h2. filter_params
+
+Macro that creates a test asserting that filter_parameter_logging is set for the specified keys.
+
+Example:
+
+  should_filter_params :password, :ssn
+  it { should filter_params(:password, :ssn) }
+
+h2. render_a_form
+
+Macro that creates a test asserting that the rendered view contains a @<form>@ element.
+
+Example:
+
+  should_render_a_form
+  it { should render_a_form }
+
+h2. render_template
+
+Macro that creates a test asserting that the controller rendered the given template.
+
+Example:
+
+  should_render_template :new
+  it { should render_template(:new) }
+
+h2. render_with_layout
+
+Macro that creates a test asserting that the controller rendered with the given layout.
+
+Example:
+
+<pre><code>  should_render_with_layout 'special'
+  should_render_with_layout :special
+
+  it { should render_with_layout{'special'} }
+  it { should render_with_layout(:special) }</code></pre>
+
+h2. render_without_layout
+
+Macro that creates a test asserting that the controller rendered without a layout. Same as @it { should render_with_layout(false) }@.
+
+h2. respond_with
+
+Macro that creates a test asserting that the controller responded with a ‘response’ status code.
+
+Example:
+
+  should_respond_with :success
+  it { should respond_with(:success) }
+
+h2. respond_with_content_type
+
+Macro that creates a test asserting that the response content type was ‘content_type’.
+
+Example:
+
+<pre><code>  should_respond_with_content_type 'application/rss+xml'
+  should_respond_with_content_type :rss
+  should_respond_with_content_type /rss/
+
+  it { should respond_with_content_type('application/rss+xml') }
+  it { should respond_with_content_type(:rss) }
+  it { should respond_with_content_type(/rss/) }</code></pre>
+
+h2. return_from_session
+
+Macro that creates a test asserting that a value returned from the session is correct. The given string is evalued to produce the resulting redirect path. All of the instance variables set by the controller are available to the evalued string.
+
+Example:
+
+  should_return_from_session(:user_id, "@user.id")
+  it { should return_from_session(:message, '"Free stuff"') }
+
+h2. route
+
+Macro that creates a routing test. It tries to use the given HTTP method on the given path, and asserts that it routes to the given options.
+
+to_param is called on the options given.
+
+Examples:
+
+<pre><code>  should_route :get, "/posts", :controller => :posts, :action => :index
+  should_route :get, "/posts/new", :controller => :posts, :action => :new
+  should_route :post, "/posts", :controller => :posts, :action => :create
+  should_route :get, "/posts/1", :controller => :posts, :action => :show, :id => 1
+
+  it { should route(:get "/posts/1/edit", :controller => :posts, :action => :edit, :id => 1) }
+  it { should route(:put, "/posts/1", :controller => :posts, :action => :update, :id => 1) }
+  it { should route(:delete, "/posts/1", :controller => :posts, :action => :destroy, :id => 1) }
+  it { should route(:get, "/users/1/posts/1",
+    :controller => :posts, :action => :show, :id => 1, :user_id => 1) }</code></pre>
+
+h2. set_the_flash_to
+
+Macro that creates a test asserting that the flash contains the given value. val can be a String, a Regex, or nil (indicating that the flash should not be set).
+
+Example:
+
+<pre><code>  should_set_the_flash_to "Thank you for placing this order."
+  should_set_the_flash_to /created/i
+  should_not set_the_flash
+
+  it { should set_the_flash_to("Thank you for placing this order.") }
+  it { should set_the_flash_to(/created/i) }
+  it { should_not set_the_flash }</code></pre>
+
+h2. redirect_to
+
+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:
+
+<pre><code>  should_redirect_to "user_post_url(@post.user, @post)"
+  should_redirect_to "user_url(@user)"
+  should_redirect_to "users_url"
+
+  it { should redirect_to(user_post_url(@post.user, @post)) }
+  it { should redirect_to(user_url(@user)) }
+  it { should redirect_to(users_url) }</code></pre>
+

data/lib/remarkable/controller/controller.rb

@@ -1,15 +1,20 @@
 require 'remarkable/controller/helpers'
-Dir[File.join(File.dirname(__FILE__), "macros", '*')].each do |file|
+Dir[File.join(File.dirname(__FILE__), "macros", '*.rb')].each do |file|
   require file
 end
+require 'remarkable/controller/macros'
 
 module Spec
   module Rails
-    module Matchers
-      include Remarkable::Controller::Helpers
+    module Example
+      class ControllerExampleGroup
+        include Remarkable::Assertions
+        include Remarkable::Controller::Matchers
+        extend Remarkable::Controller::Macros
+
+        private
+        include Remarkable::Private
+      end
     end
   end
 end
-
-Spec::Rails::Matchers.send(:include, Remarkable::Syntax::RSpec)
-Spec::Example::ExampleGroupMethods.send(:include, Remarkable::Syntax::Shoulda)

data/lib/remarkable/controller/helpers.rb

@@ -1,46 +1,12 @@
 module Remarkable # :nodoc:
   module Controller # :nodoc:
     module Helpers # :nodoc:
+      include Remarkable::Default::Helpers
+      
       private # :enddoc:
 
-      SPECIAL_INSTANCE_VARIABLES = %w{
-        _cookies
-        _flash
-        _headers
-        _params
-        _request
-        _response
-        _session
-        action_name
-        before_filter_chain_aborted
-        cookies
-        flash
-        headers
-        ignore_missing_templates
-        logger
-        params
-        request
-        request_origin
-        response
-        session
-        template
-        template_class
-        template_root
-        url
-        variables_added
-        }.map(&:to_s)
-
-      def instantiate_variables_from_assigns(*names, &blk)
-        old = {}
-        names = (response.template.assigns.keys - SPECIAL_INSTANCE_VARIABLES) if names.empty?
-        names.each do |name|
-          old[name] = instance_variable_get("@#{name}")
-          instance_variable_set("@#{name}", assigns(name.to_sym))
-        end
-        blk.call
-        names.each do |name|
-          instance_variable_set("@#{name}", old[name])
-        end
+      def controller_assigns(key)
+        @controller.instance_variable_get("@#{key}")
       end
       
     end

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

@@ -0,0 +1,85 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class AssignMatcher < Remarkable::Matcher::Base
+        include Remarkable::Controller::Helpers
+        
+        def initialize(*names)
+          @options = names.extract_options!
+          @names   = names
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          initialize_with_spec!
+
+          assert_matcher_for(@names) do |name|
+            @name = name
+            assigned_value? && is_kind_of? && is_equals_expected_value?
+          end
+        end
+
+        def description
+          description = "assign @#{@names.to_sentence}"
+          description << " as class #{@options[:class]}" if @options[:class]
+          description << " which is equal to #{@options[:equals]}" if @options[:equals]
+          description
+        end
+        
+        private
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @controller = @subject
+          #
+          @controller = @spec.instance_eval { controller }
+        end
+
+        def assigned_value?
+          @assigned_value = controller_assigns(@name.to_sym)
+          return true unless @assigned_value.nil?
+
+          @missing = "the action isn't assigning to @#{@name}"
+          return false
+        end
+        
+        def is_kind_of?
+          return true unless @options[:class]
+          return true if @assigned_value.kind_of?(@options[:class])
+          
+          @missing = "@#{@name} is not a kind of #{@options[:class]}"
+          return false
+        end
+        
+        def is_equals_expected_value?
+          return true unless @options[:equals]
+
+          expected_value = if @options[:equals].is_a?(String)
+            @spec.instance_eval(@options[:equals]) rescue @options[:equals]
+          else
+            @options[:equals]
+          end
+          return true if @assigned_value == expected_value
+
+          @missing = "instance variable @#{@name} expected to be #{expected_value.inspect} but was #{@assigned_value.inspect}"
+          return false
+        end
+        
+        def expectation
+          expectation = "assign @#{@name}"
+          expectation << " as class #{@options[:class]}" if @options[:class]
+          expectation << " which is equal to #{@options[:equals].inspect}" if @options[:equals]
+          expectation
+        end
+
+      end
+
+      def assign_to(*names)
+        AssignMatcher.new(*names)
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class FilterParams < Remarkable::Matcher::Base
+        include Remarkable::Controller::Helpers
+
+        def initialize(*keys)
+          @options = keys.extract_options!
+          @keys    = keys
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          initialize_with_spec!
+          
+          assert_matcher_for(@keys) do |key|
+            @key = key
+            respond_to_filter_parameters? && is_filtered?
+          end
+        end
+
+        def description
+          "filter #{@keys.to_sentence}"
+        end
+
+        private
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @controller = @subject
+          #
+          @controller = @spec.instance_eval { controller }
+        end
+
+        def respond_to_filter_parameters?
+          return true if @controller.respond_to?(:filter_parameters)
+          
+          @missing = "The key #{@key} is not filtered"
+          return false
+        end
+
+        def is_filtered?
+          filtered = @controller.send(:filter_parameters, { @key.to_s => @key.to_s })
+          return true if filtered[@key.to_s] == '[FILTERED]'
+          
+          @missing = "The key #{@key} is not filtered"
+          return false
+        end
+
+        def expectation
+          "filter #{@key}"
+        end
+
+      end
+
+      def filter_params(*keys)
+        FilterParams.new(*keys)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# module Remarkable # :nodoc:
+#   module Controller # :nodoc:
+#     module Matchers # :nodoc:
+#       class MetadataMatcher < Remarkable::Matcher::Base
+#         include Remarkable::Controller::Helpers
+#         include Test::Unit::Assertions
+#         include ActionController::Assertions::SelectorAssertions
+#         
+#         def initialize(options)
+#           @options = options
+#         end
+# 
+#         def matches?(subject)
+#           @subject = subject
+#           
+#           assert_matcher_for(@options) do |option|
+#             @key, @value = option
+#             body_is_blank? && has_metatag?
+#           end
+#         end
+# 
+#         def description
+#           "have metatag #{@options.inspect}"
+#         end
+#         
+#         private
+#         
+#         def body_is_blank?
+#           return true unless @response.body.strip.empty?
+#           
+#           @missing = "response.body is empty, integrate_views was included in your spec?"
+#           false
+#         end
+#         
+#         def has_metatag?
+#           begin          
+#             if @key.to_sym == :title
+#               return true if assert_select("title", @value)
+#             else
+#               return true if assert_select("meta[name=?][content#{"*" if @value.is_a?(Regexp)}=?]", @key, @value)
+#             end
+#           rescue
+#             @missing = "Expected metatag #{@key} matching \"#{@value}\", not found."
+#             return false
+#           end
+#         end
+#         
+#         def html_document
+#           xml = @response.content_type =~ /xml$/
+#           @html_document ||= HTML::Document.new(@response.body, false, xml)
+#         end
+#                 
+#         def expectation
+#           "have metatag #{@key}"
+#         end
+#       end
+# 
+#       def render_page_with_metadata(options)
+#         MetadataMatcher.new(options)
+#       end
+#     end
+#   end
+# end

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

@@ -0,0 +1,75 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class RenderWithLayout < Remarkable::Matcher::Base
+        def initialize(expected_layout = 'application')
+          @expected_layout = expected_layout
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          initialize_with_spec!
+
+          assert_matcher do
+            if @expected_layout
+              with_layout?
+            else
+              without_layout?
+            end
+          end
+        end
+        
+        def description
+          expectation
+        end
+        
+        def failure_message
+          @missing
+        end
+        
+        private
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @response = @subject.response
+          #
+          @response = @spec.instance_eval { response }
+        end
+
+        def with_layout?
+          response_layout = @response.layout.blank? ? "" : @response.layout.split('/').last
+          return true if response_layout == @expected_layout.to_s
+          
+          @missing = "Expected to render with layout #{@expected_layout} but was rendered with #{response_layout}"
+          return false
+        end
+        
+        def without_layout?
+          return true if @response.layout.nil?
+          
+          @missing = "Expected no layout, but was rendered using #{@response.layout}"
+          return false
+        end
+        
+        def expectation
+          if @expected_layout
+            "render with #{@expected_layout.inspect} layout"
+          else
+            "render without layout"
+          end
+        end
+
+      end
+
+      def render_with_layout(expected_layout = 'application')
+        RenderWithLayout.new(expected_layout)
+      end
+      
+      def render_without_layout
+        RenderWithLayout.new(nil)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class RespondWithContentType < Remarkable::Matcher::Base
+        def initialize(content_type)
+          @content_type = content_type
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          initialize_with_spec!
+
+          assert_matcher do
+            content_type_correct?
+          end
+        end
+
+        def description
+          expectation
+        end
+
+        def failure_message
+          @missing
+        end
+
+        private
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @response = @subject.response
+          #
+          @response = @spec.instance_eval { response }
+        end
+
+        def content_type_correct?
+          @content_type = Mime::EXTENSION_LOOKUP[@content_type.to_s].to_s if @content_type.is_a?(Symbol)
+          if @content_type.is_a?(Regexp)
+            return true if @response.content_type =~ @content_type
+            @missing = "Expected to match #{@content_type} but was actually #{@response.content_type}"
+          else
+            return true if @response.content_type == @content_type
+            @missing = "Expected #{@content_type} but was actually #{@response.content_type}"
+          end
+          return false
+        end
+        
+        def expectation
+          "respond with content type of #{@content_type}"
+        end
+
+      end
+
+      def respond_with_content_type(content_type)
+        RespondWithContentType.new(content_type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class RespondWith < Remarkable::Matcher::Base
+        def initialize(type)
+          @type = type
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          initialize_with_spec!
+
+          assert_matcher do
+            respond_with_type?
+          end
+        end
+
+        def description
+          expectation
+        end
+
+        def failure_message
+          @missing
+        end
+        
+        private
+        
+        def respond_with_type?
+          return true if [:success, :missing, :redirect, :error].include?(@type) && @response.send("#{@type}?")
+          return true if @type.is_a?(Fixnum) && @response.response_code == @type
+          return true if @type.is_a?(Symbol) && @response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@type]
+          
+          @missing = if @response.error?
+            exception = @response.template.instance_variable_get(:@exception)
+            exception_message = exception && exception.message
+            "Expected response to be a #{@type}, but was #{@response.response_code}\n#{exception_message.to_s}"
+          else
+            "Expected response to be a #{@type}, but was #{@response.response_code}"
+          end
+          return false
+        end
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @response = @subject.response
+          #
+          @response = @spec.instance_eval { response }
+        end
+
+        def expectation
+          "respond with #{@type}"
+        end
+      end
+      
+      def respond_with(type)
+        RespondWith.new(type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class ReturnFromSession < Remarkable::Matcher::Base
+        include Remarkable::Controller::Helpers
+        
+        def initialize(key, expected)
+          @key      = key
+          @expected = expected
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          initialize_with_spec!
+
+          assert_matcher do
+            has_session_key?
+          end
+        end
+
+        def description
+          expectation
+        end
+
+        def failure_message
+          @missing
+        end
+
+        private
+
+        def has_session_key?
+          expected_value = @spec.instance_eval(@expected) rescue @expected
+          return true if @session[@key] == expected_value
+
+          @missing = "Expected #{expected_value.inspect} but was #{@session[@key]}"
+          return false
+        end
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @session = @subject.session
+          #
+          @session = @spec.instance_eval { session }
+        end
+        
+        def expectation
+          "return the correct value from the session for key #{@key}"
+        end
+      end
+
+      def return_from_session(key, expected)
+        ReturnFromSession.new(key, expected)
+      end
+    end
+  end
+end