remarkable_rails 3.0.0

data/lib/remarkable_rails/action_controller/matchers/assign_to_matcher.rb

@@ -0,0 +1,94 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      class AssignToMatcher < Remarkable::ActionController::Base #:nodoc:
+        arguments :collection => :names, :as => :name, :block => :block
+
+        optional :with, :with_kind_of
+        collection_assertions :assigned_value?, :is_kind_of?, :is_equal_value?
+
+        before_assert :evaluate_expected_value
+
+        default_options :with_expectations => true
+
+        protected
+
+          def assigned_value?
+            assigns.key?(@name)
+          end
+
+          def is_kind_of?
+            return true unless @options[:with_kind_of]
+            return assigns[@name].kind_of?(@options[:with_kind_of])
+          end
+
+          # Returns true if :with is not given and no block is given.
+          # In case :with is a proc or a block is given, we evaluate it in the
+          # @spec scope.
+          #
+          def is_equal_value?
+            return true unless value_to_compare?
+            assigns[@name] == @options[:with]
+          end
+
+          def assigns
+            @subject.response.template.assigns.with_indifferent_access
+          end
+
+          def value_to_compare?
+            @options.key?(:with) || @block
+          end 
+
+          # Update interpolation options
+          def interpolation_options
+            if @subject && @subject.response
+              { :assign_inspect => assigns[@name].inspect, :assign_class => assigns[@name].class.name }
+            else
+              { }
+            end
+          end
+
+          # Evaluate procs before assert to avoid them appearing in descriptions.
+          def evaluate_expected_value
+            if value_to_compare?
+              value = @options.key?(:with) ? @options[:with] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:with] = value
+            end
+          end
+
+      end
+
+      # Checks if the controller assigned the variables given by name. If you
+      # want to check that a variable is not being assigned, please do:
+      #
+      #   should_not_assign_to(:user)
+      #
+      # If you want to assure that a variable is being assigned to nil, do instead:
+      #
+      #   should_assign_to(:user).with(nil)
+      #
+      # == Options
+      #
+      # * <tt>:with</tt> - The value to compare the assign.
+      #   It can be also be supplied as proc or as a block (see examples below)
+      #
+      # * <tt>:with_kind_of</tt> - The expected class of the assign.
+      #
+      # == Examples
+      #
+      #   should_assign_to :user, :with_kind_of => User
+      #   should_assign_to :user, :with => proc{ users(:first) }
+      #   should_assign_to(:user){ users(:first) }
+      #
+      #   it { should assign_to(:user) }
+      #   it { should assign_to(:user, :with => users(:first)) }
+      #   it { should assign_to(:user, :with_kind_of => User) }
+      #
+      def assign_to(*args, &block)
+        AssignToMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/matchers/filter_params_matcher.rb

@@ -0,0 +1,41 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
+      class FilterParamsMatcher < Remarkable::Base #:nodoc:
+        arguments :collection => :params, :as => :param
+
+        assertions :respond_to_filter_params?
+        collection_assertions :is_filtered?
+
+        protected
+
+          def respond_to_filter_params?
+            @subject.respond_to?(:filter_parameters)
+          end
+
+          def is_filtered?
+            filtered = @subject.send(:filter_parameters, { @param.to_s => @param.to_s })
+            filtered[@param.to_s] == '[FILTERED]'
+          end
+
+      end
+
+      # Checks if the controller filters the given params.
+      #
+      # == Examples
+      #
+      #   should_filter_params :password
+      #   should_not_filter_params :username
+      #
+      #   it { should filter_params(:password) }
+      #   it { should_not filter_params(:username) }
+      #
+      def filter_params(*params)
+        FilterParamsMatcher.new(*params).spec(self)
+      end
+      alias :filter_param :filter_params
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/matchers/redirect_to_matcher.rb

@@ -0,0 +1,119 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      class RedirectToMatcher < Remarkable::ActionController::Base #:nodoc:
+        include ::ActionController::StatusCodes
+
+        arguments :expected, :block => :block
+        optional :with
+
+        assertions :redirected?, :status_matches?, :url_matches?
+
+        before_assert :evaluate_expected_value
+
+        before_assert do
+          @response = @subject.respond_to?(:response) ? @subject.response : @subject
+          @request  = @response.instance_variable_get('@request')
+        end
+
+        protected
+
+          def redirected?
+            @response.redirect?
+          end
+
+          def status_matches?
+            return true unless @options.key?(:with)
+
+            actual_status   = interpret_status(@response.response_code)
+            expected_status = interpret_status(@options[:with])
+
+            return actual_status == expected_status, :status => @response.response_code.inspect
+          end
+
+          def url_matches?
+            @actual = @response.redirect_url
+
+            if @expected.instance_of?(Hash)
+              return false unless @actual =~ /^\w+:\/\/#{@request.host}/ && actual_hash
+              actual_hash == expected_hash
+            else
+              @actual == expected_url
+            end
+          end
+
+          def actual_hash
+            hash_from_url @actual
+          end
+
+          def expected_hash
+            hash_from_url expected_url
+          end
+
+          def hash_from_url(url)
+            query_hash(url).merge(path_hash(url)).with_indifferent_access
+          end
+
+          def path_hash(url)
+            path = url.sub(/^\w+:\/\/#{@request.host}(?::\d+)?/, "").split("?", 2)[0]
+            ::ActionController::Routing::Routes.recognize_path path, { :method => :get }
+          end
+
+          def query_hash(url)
+            query = url.split("?", 2)[1] || ""
+
+            if defined?(::Rack::Utils)
+              ::Rack::Utils.parse_query(query)
+            else
+              @request.class.parse_query_parameters(query)
+            end
+          end
+
+          def expected_url
+            case @expected
+              when Hash
+                return ::ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+              when :back
+                return @request.env['HTTP_REFERER']
+              when %r{^\w+://.*}
+                return @expected
+              else
+                return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+            end
+          end
+
+          def interpolation_options
+            { :expected => @expected.inspect, :actual => @actual.inspect }
+          end
+
+          def evaluate_expected_value
+            @expected ||= @block if @block
+            @expected = @spec.instance_eval(&@expected) if @expected.is_a?(Proc)
+          end
+
+      end
+
+      # Passes if the response redirects to the given url. The url can be a string,
+      # a hash or can be supplied as a block (see examples below).
+      #
+      # == Options
+      #
+      # * <tt>:with</tt> - The status 30X used when redirecting.
+      #
+      # == Examples
+      #
+      #   should_redirect_to{ users_url }
+      #   should_redirect_to(:action => 'index')
+      #   should_not_redirect_to(:controller => 'users', :action => 'new')
+      #
+      #   it { should redirect_to(users_url).with(302) }
+      #   it { should redirect_to(:action => 'index') }
+      #   it { should_not redirect_to(:controller => 'users', :action => 'new') }
+      #
+      def redirect_to(expected=nil, options={}, &block)
+        RedirectToMatcher.new(expected, options, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/matchers/render_template_matcher.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__), 'respond_with_matcher') 
+
+module Remarkable
+  module ActionController
+    module Matchers
+      class RenderTemplateMatcher < RespondWithMatcher #:nodoc:
+
+        prepend_optional :template, :layout
+
+        assertions :rendered?, :template_matches?, :layout_matches?
+
+        protected
+
+          def rendered?
+            return true unless @options.key?(:template)
+
+            @actual = if @response.respond_to?(:rendered_file)
+              @response.rendered_file
+            elsif @response.respond_to?(:rendered)
+              case template = @response.rendered[:template]
+                when nil
+                  unless @response.rendered[:partials].empty?
+                    path_and_file(response.rendered[:partials].keys.first).join("/_")
+                  end
+                when ::ActionView::Template
+                  template.path
+                when ::String
+                  template
+              end
+            else
+              @response.rendered_template.to_s
+            end
+
+            !@actual.blank?
+          end
+
+          def template_matches?
+            return true unless @options[:template] # only continue if not nil
+
+            actual_controller_path, actual_file     = path_and_file(@actual.to_s)
+            expected_controller_path, expected_file = path_and_file(@options[:template].to_s)
+
+            # Test if each given slice matches. Actual always return the full
+            # file name (new.html.erb), on the other hand, the user might supply
+            # only new. If the user supply all three pieces, we check if they
+            # are equal, in the given order.
+            #
+            actual_file = actual_file.split('.')
+            expected_file.split('.').each_with_index do |slice, i|
+              return false unless slice == actual_file[i] || actual_file[i].nil?
+            end
+
+            actual_controller_path == expected_controller_path 
+          end
+
+          def layout_matches?
+            return true unless @options.key?(:layout)
+            @response.layout.to_s.split('/').last.to_s == @options[:layout].to_s
+          end
+
+          def path_and_file(path)
+            parts = path.split('/')
+            file = parts.pop
+            controller = parts.empty? ? @controller.controller_path : parts.join('/')
+            return controller, file
+          end
+
+          def interpolation_options
+            if @response
+              super.merge!(:actual_layout => @response.layout.inspect, :actual_template => @actual.inspect)
+            else
+              super.merge!(:actual_template => @actual.inspect)
+            end
+          end
+
+      end
+
+      # Passes if the specified template (view file) is rendered by the
+      # response. This file can be any view file, including a partial.
+      #
+      # <code>template</code> can include the controller path. It can also
+      # include an optional extension, which you only need to use when there
+      # is ambiguity.
+      #
+      # Note that partials must be spelled with the preceding underscore.
+      #
+      # == Options
+      #
+      # * <tt>:layout</tt> - The layout used when rendering the template.
+      #
+      # All other options in <tt>respond_with</tt> are also available.
+      #
+      # == Examples
+      #
+      #   should_render_template 'list'
+      #   should_render_template 'same_controller/list'
+      #   should_render_template 'other_controller/list'
+      #
+      # # with extensions
+      #   should_render_template 'list.rjs'
+      #   should_render_template 'list.haml'
+      #   should_render_template 'same_controller/list.rjs'
+      #   should_render_template 'other_controller/list.rjs'
+      #
+      # # partials
+      #   should_render_template '_a_partial'
+      #   should_render_template 'same_controller/_a_partial'
+      #   should_render_template 'other_controller/_a_partial'
+      #
+      # # with options
+      #   should_render_template 'list', :layout => 'users'
+      #   should_render_template 'list', :content_type => :xml
+      #   should_render_template 'list', :content_type => /xml/
+      #   should_render_template 'list', :content_type => Mime::XML
+      #
+      #   it { should render_template('list').layout('users') }
+      #   it { should render_template('list').content_type(:xml) }
+      #   it { should render_template('list').content_type(/xml/) }
+      #   it { should render_template('list').content_type(Mime::XML) }
+      #
+      # == Gotcha
+      #
+      # Extensions check does not work in Rails 2.1.x.
+      #
+      def render_template(*args)
+        options = args.extract_options!
+        RenderTemplateMatcher.new(options.merge(:template => args.first)).spec(self)
+      end
+
+      # This is just a shortcut for render_template :layout => layout. It's also
+      # used for Shoulda compatibility. Check render_template for more information.
+      #
+      def render_with_layout(*args)
+        options = args.extract_options!
+        RenderTemplateMatcher.new(options.merge(:layout => args.first)).spec(self)
+      end
+
+      # This is just a shortcut for render_template :layout => nil. It's also
+      # used for Shoulda compatibility. Check render_template for more information.
+      #
+      def render_without_layout(options={})
+        RenderTemplateMatcher.new(options.merge(:layout => nil)).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/matchers/respond_with_matcher.rb

@@ -0,0 +1,125 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      class RespondWithMatcher < Remarkable::ActionController::Base #:nodoc:
+
+        arguments
+
+        optional :with, :body, :content_type
+
+        before_assert do
+          @response   = @subject.respond_to?(:response) ? @subject.response : @subject
+          @controller = @spec.instance_variable_get('@controller')
+        end
+
+        before_assert :evaluate_content_type
+
+        assertions :status_matches?, :body_matches?, :content_type_matches?
+
+        protected
+
+          def status_matches?
+            return true unless @options[:with] # only continue if not nil
+
+            case @options[:with]
+              when :success, :missing, :redirect, :error
+                @response.send("#{@options[:with]}?")
+              when Fixnum
+                @response.response_code == @options[:with]
+              when Symbol, String
+                @response.response_code == ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@options[:with].to_sym]
+              when Range
+                @options[:with].include?(@response.response_code)
+              else
+                raise ArgumentError, "I don't know how to interpret status #{@options[:with].inspect}, " <<
+                                      "please give me a Fixnum, Symbol, String or Range."
+            end
+          end
+
+          def body_matches?
+            return true unless @options.key?(:body)
+            assert_contains(@response.body, @options[:body])
+          end
+
+          def content_type_matches?
+            return true unless @options.key?(:content_type)
+            assert_contains(@response.content_type, @options[:content_type])
+          end
+
+          # Evaluate content_type before assertions to have nice descriptions
+          def evaluate_content_type
+            return unless @options.key?(:content_type)
+
+            @options[:content_type] = case @options[:content_type]
+              when Symbol
+                Mime::Type.lookup_by_extension(@options[:content_type].to_s).to_s
+              when Regexp
+                @options[:content_type]
+              else
+                @options[:content_type].to_s
+            end
+          end
+
+          def interpolation_options
+            if @response
+              { :actual_body => @response.body.inspect,
+                :actual_status => @response.response_code.inspect,
+                :actual_content_type => @response.content_type.inspect }
+            else
+              { }
+            end
+          end
+
+      end
+
+      # Passes if the response has the given status. Status can be a Symbol lik
+      # :success, :missing, :redirect and :error. Can be also a Fixnum, Range o
+      # any other symbol which matches to any of Rails status codes. 
+      #
+      # == Options
+      #
+      # * <tt>:body</tt> - The body of the response. It accepts strings and or
+      #   regular expressions. Altought you might be running your tests without
+      #   integrating your views, this is useful when rendering :xml or :text.
+      #
+      # * <tt>:content_type</tt> - The content type of the response.
+      #   It accepts strings ('application/rss+xml'), mime constants (Mime::RSS),
+      #   symbols (:rss) and regular expressions /rss/.
+      #
+      # == Examples
+      #
+      #   should_respond_with :success
+      #   should_respond_with :error,   :body => /System error/
+      #   should_respond_with 301,      :content_type => Mime::XML
+      #   should_respond_with 300..399, :content_type => Mime::XML
+      #
+      #   it { should respond_with(:success)                              }
+      #   it { should respond_with(:error).body(/System error/)           }
+      #   it { should respond_with(301).content_type(Mime::XML)      }
+      #   it { should respond_with(300..399).content_type(Mime::XML) }
+      #
+      def respond_with(*args)
+        options = args.extract_options!
+        RespondWithMatcher.new(options.merge(:with => args.first)).spec(self)
+      end
+
+      # This is just a shortcut for respond_with :body => body. Check respond_with
+      # for more information.
+      #
+      def respond_with_body(*args)
+        options = args.extract_options!
+        RespondWithMatcher.new(options.merge(:body => args.first)).spec(self)
+      end
+
+      # This is just a shortcut for respond_with :content_type => content_type.
+      # It's also used for Shoulda compatibility. Check respond_with for more
+      # information.
+      #
+      def respond_with_content_type(*args)
+        options = args.extract_options!
+        RespondWithMatcher.new(options.merge(:content_type => args.first)).spec(self)
+      end
+
+    end
+  end
+end