merb-core 0.9.2

data/lib/merb-core/test/helpers/request_helper.rb

@@ -0,0 +1,257 @@
+require 'tempfile'
+
+module Merb
+  module Test
+    module RequestHelper
+      # FakeRequest sets up a default enviroment which can be overridden either
+      # by passing and env into initialize or using request['HTTP_VAR'] = 'foo'
+      class FakeRequest < Request
+
+        # ==== Parameters
+        # env<Hash>:: Environment options that override the defaults.
+        # req<StringIO>:: The request to set as input for Rack.
+        def initialize(env = {}, req = StringIO.new)
+          env.environmentize_keys!
+          env['rack.input'] = req
+          super(DEFAULT_ENV.merge(env))
+        end
+    
+        private
+        DEFAULT_ENV = Mash.new({
+          'SERVER_NAME' => 'localhost',
+          'PATH_INFO' => '/',
+          'HTTP_ACCEPT_ENCODING' => 'gzip,deflate',
+          'HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.8.0.1) Gecko/20060214 Camino/1.0',
+          'SCRIPT_NAME' => '/',
+          'SERVER_PROTOCOL' => 'HTTP/1.1',
+          'HTTP_CACHE_CONTROL' => 'max-age=0',
+          'HTTP_ACCEPT_LANGUAGE' => 'en,ja;q=0.9,fr;q=0.9,de;q=0.8,es;q=0.7,it;q=0.7,nl;q=0.6,sv;q=0.5,nb;q=0.5,da;q=0.4,fi;q=0.3,pt;q=0.3,zh-Hans;q=0.2,zh-Hant;q=0.1,ko;q=0.1',
+          'HTTP_HOST' => 'localhost',
+          'REMOTE_ADDR' => '127.0.0.1',
+          'SERVER_SOFTWARE' => 'Mongrel 1.1',
+          'HTTP_KEEP_ALIVE' => '300',
+          'HTTP_REFERER' => 'http://localhost/',
+          'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+          'HTTP_VERSION' => 'HTTP/1.1',
+          'REQUEST_URI' => '/',
+          'SERVER_PORT' => '80',
+          'GATEWAY_INTERFACE' => 'CGI/1.2',
+          'HTTP_ACCEPT' => 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5',
+          'HTTP_CONNECTION' => 'keep-alive',
+          'REQUEST_METHOD' => 'GET'      
+        }) unless defined?(DEFAULT_ENV)
+      end
+
+      # ==== Parameters
+      # env<Hash>:: A hash of environment keys to be merged into the default list.
+      # opt<Hash>:: A hash of options (see below).
+      #
+      # ==== Options (opt)
+      # :post_body<String>:: The post body for the request.
+      # :req<String>::
+      #   The request string. This will only be used if :post_body is left out.
+      # 
+      # ==== Returns
+      # FakeRequest:: A Request object that is built based on the parameters.
+      #
+      # ==== Note
+      # If you pass a post body, the content-type will be set to URL-encoded.
+      #
+      #---
+      # @public
+      def fake_request(env = {}, opt = {})
+        if opt[:post_body]
+          req = opt[:post_body]
+          env[:content_type] ||= "application/x-www-form-urlencoded"
+        else
+          req = opt[:req]
+        end
+        FakeRequest.new(env, StringIO.new(req || '')) 
+      end
+
+      # Dispatches an action to the given class. This bypasses the router and is
+      # suitable for unit testing of controllers.
+      #
+      # ==== Parameters
+      # controller_klass<Controller>::
+      #   The controller class object that the action should be dispatched to.
+      # action<Symbol>:: The action name, as a symbol.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+), including :req or :post_body
+      #   for setting the request body itself.
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Example
+      #   dispatch_to(MyController, :create, :name => 'Homer' ) do
+      #     self.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Note
+      # Does not use routes.
+      #
+      #---
+      # @public
+      def dispatch_to(controller_klass, action, params = {}, env = {}, &blk)
+        action = action.to_s
+        request_body = { :post_body => env[:post_body], :req => env[:req] }
+        request = fake_request(env.merge(
+          :query_string => Merb::Request.params_to_query_string(params)), request_body)
+
+        dispatch_request(request, controller_klass, action, &blk)
+      end
+  
+      # An HTTP GET request that operates through the router.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+).
+      # &block:: The block is executed in the context of the controller.
+      def get(path, params = {}, env = {}, &block)
+        env[:request_method] = "GET"
+        request(path, params, env, &block)
+      end
+  
+      # An HTTP POST request that operates through the router.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see fake_request).
+      # &block:: The block is executed in the context of the controller.
+      def post(path, params = {}, env = {}, &block)
+        env[:request_method] = "POST"
+        request(path, params, env, &block)
+      end
+  
+      # An HTTP PUT request that operates through the router.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see fake_request).
+      # &block:: The block is executed in the context of the controller.
+      def put(path, params = {}, env = {}, &block)
+        env[:request_method] = "PUT"
+        request(path, params, env, &block)
+      end
+  
+      # An HTTP DELETE request that operates through the router
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see fake_request).
+      # &block:: The block is executed in the context of the controller.
+      def delete(path, params = {}, env = {}, &block)
+        env[:request_method] = "DELETE"
+        request(path, params, env, &block)
+      end
+
+      # A generic request that checks the router for the controller and action.
+      # This request goes through the Merb::Router and finishes at the controller.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+).
+      # blk<Proc>:: The block is executed in the context of the controller.
+      #
+      # ==== Example
+      #   request(path, :create, :name => 'Homer' ) do
+      #     self.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Note
+      # Uses Routes.
+      #
+      #---
+      # @semi-public  
+      def request(path, params = {}, env= {}, &block)
+        env[:request_method] ||= "GET"
+        env[:request_uri] = path
+        multipart = env.delete(:test_with_multipart)
+    
+        request = fake_request(env)
+    
+        opts = check_request_for_route(request) # Check that the request will be routed correctly
+        klass = Object.full_const_get(opts.delete(:controller).to_const_string)
+        action = opts.delete(:action).to_s
+        params.merge!(opts)
+  
+        multipart.nil? ? dispatch_to(klass, action, params, env, &block) : dispatch_multipart_to(klass, action, params, env, &block)
+      end
+
+
+      # The workhorse for the dispatch*to helpers.
+      # 
+      # ==== Parameters
+      # request<Merb::Test::FakeRequest, Merb::Request>::
+      #   A request object that has been setup for testing.
+      # controller_klass<Merb::Controller>::
+      #   The class object off the controller to dispatch the action to.
+      # action<Symbol>:: The action to dispatch the request to.
+      # blk<Proc>:: The block will execute in the context of the controller itself.
+      #
+      # ==== Returns
+      # An instance of +controller_klass+ based on the parameters.
+      #
+      # ==== Note
+      # Does not use routes.
+      #
+      #---
+      # @private
+      def dispatch_request(request, controller_klass, action, &blk)
+        controller = controller_klass.new(request)
+        yield controller if block_given?
+        controller._dispatch(action)
+
+        Merb.logger.info controller._benchmarks.inspect
+        Merb.logger.flush
+
+        controller
+      end
+
+      # Checks to see that a request is routable.
+      # 
+      # ==== Parameters
+      # request<Merb::Test::FakeRequest, Merb::Request>::
+      #   The request object to inspect.
+      #
+      # ==== Raises
+      # Merb::ControllerExceptions::BadRequest::
+      #   No matching route was found.
+      #
+      # ==== Returns
+      # Hash:: The parameters built based on the matching route.
+      def check_request_for_route(request)
+        match =  ::Merb::Router.match(request)
+        if match[0].nil?
+          raise ::Merb::ControllerExceptions::BadRequest, "No routes match the request"
+        else
+          match[1]
+        end
+      end
+    end
+  end
+end

data/lib/merb-core/test/helpers/route_helper.rb

@@ -0,0 +1,33 @@
+module Merb
+  module Test
+    module RouteHelper
+      include RequestHelper
+      
+      # Mimics the url method available to controllers.
+      #
+      # ==== Parameters
+      # name<~to_sym>:: The name of the URL to generate.
+      # params<Hash>:: Parameters for the route generation.
+      #
+      # ==== Returns
+      # String:: The generated URL.
+      def url(name, params={})
+        Merb::Router.generate(name, params)
+      end
+      
+      # ==== Parameters
+      # path<~to_string>:: The URL of the request.
+      # method<~to_sym>:: HTTP request method.
+      # env<Hash>:: Additional parameters for the request.
+      #
+      # ==== Returns
+      # Hash:: A hash containing the controller and action along with any parameters
+      def request_to(path, method = :get, env = {})
+        env[:request_method] ||= method.to_s.upcase
+        env[:request_uri] = path
+        
+        check_request_for_route(fake_request(env))
+      end
+    end
+  end
+end

data/lib/merb-core/test/helpers/view_helper.rb

@@ -0,0 +1,121 @@
+module Merb
+  module Test
+    module ViewHelper
+
+      # Small utility class for working with the Hpricot parser class
+      class DocumentOutput
+
+        # ==== Parameters
+        # response_body<String>:: The response body to parse with Hpricot.
+        def initialize(response_body)
+          @parser = Hpricot.parse(response_body)
+        end
+
+        # ==== Parameters
+        # css_query<String>::
+        #   A CSS query to find the element for, e.g. "ul.links".
+        #
+        # ==== Returns
+        # String:: The content of the first tag matching the query.
+        def content_for(css_query)
+          match = @parser.search(css_query).first
+          match.inner_text unless match.nil?
+        end
+
+        # ==== Parameters
+        # css_query<String>:: A CSS query to find the elements for.
+        #
+        # ==== Returns
+        # Array[String]:: Content of all tags matching the query.
+        def content_for_all(css_query)
+          matches = @parser.search(css_query).collect{|ele| ele.inner_text}
+        end
+
+        # ==== Parameters
+        # css_query<String>:: A CSS query to find the elements for.
+        #
+        # ==== Returns
+        # Hpricot::Elements:: All tags matching the query.
+        def [](css_query)
+          @parser.search(css_query)
+        end
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the element for.
+      # output<DocumentOutput>::
+      #   The output to look for the element in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # String:: The content of the first tag matching the query.
+      def tag(css_query, output = process_output)
+        output.content_for(css_query)
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the elements for.
+      # output<DocumentOutput>::
+      #   The output to look for the element in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Array[String]:: Content of all tags matching the query.
+      def tags(css_query, output = process_output)
+        output.content_for_all(css_query)
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the element for.
+      # output<DocumentOutput>::
+      #   The output to look for the element in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Hpricot::Elem:: The first tag matching the query.
+      def element(css_query, output = process_output)
+        output[css_query].first
+      end
+  
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the elements for.
+      # output<DocumentOutput>::
+      #   The output to look for the elements in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Array[Hpricot::Elem]:: All tags matching the query.
+      def elements(css_query, output = process_output)
+        Hpricot::Elements[*css_query.to_s.split(",").map{|s| s.strip}.map do |query|
+          output[query]
+        end.flatten]
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the elements for.
+      # text<String, Regexp>:: A pattern to match tag contents for.
+      # output<DocumentOutput>::
+      #   The output to look for the elements in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Array[Hpricot::Elem]:: All tags matching the query and pattern.
+      def get_elements(css_query, text, output = nil)
+        els = elements(*[css_query, output].compact)
+        case text
+          when String then els.reject {|t| !t.contains?(text) }
+          when Regexp then els.reject {|t| !t.matches?(text) }
+          else []
+        end
+      end
+  
+      protected
+
+        # ==== Returns
+        # DocumentOutput:: Document output from the response body.
+        def process_output
+          return @output unless @output.nil?
+          return @output = DocumentOutput.new(@response_output) unless @response_output.nil?
+          
+          raise "The response output was not in it's usual places, please provide the output" if @controller.nil? || @controller.body.empty?
+          @response_output = @controller.body
+          @output = DocumentOutput.new(@controller.body)
+        end
+    end
+  end
+end

data/lib/merb-core/test/matchers.rb

@@ -0,0 +1,9 @@
+module Merb::Test::Rspec; end
+
+require "merb-core/test/matchers/controller_matchers"
+require "merb-core/test/matchers/route_matchers"
+require "merb-core/test/matchers/view_matchers"
+
+Merb::Test::ControllerHelper.send(:include, Merb::Test::Rspec::ControllerMatchers)
+Merb::Test::RouteHelper.send(:include, Merb::Test::Rspec::RouteMatchers)
+Merb::Test::ViewHelper.send(:include, Merb::Test::Rspec::ViewMatchers)

data/lib/merb-core/test/matchers/controller_matchers.rb

@@ -0,0 +1,269 @@
+module Merb::Test::Rspec::ControllerMatchers
+
+  class BeRedirect
+
+    # ==== Parameters
+    # target<Fixnum, ~status>::
+    #   Either the status code or a controller with a status code.
+    #
+    # ==== Returns
+    # Boolean:: True if the status code is in the range 300..305 or 307.
+    def matches?(target)
+      @target = target
+      [307, *(300..305)].include?(target.respond_to?(:status) ? target.status : target)
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected#{inspect_target} to redirect"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected#{inspect_target} not to redirect"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      " #{@target.controller_name}##{@target.action_name}" if @target.respond_to?(:controller_name) && @target.respond_to?(:action_name)
+    end
+  end
+
+  class RedirectTo
+
+    # === Parameters
+    # String:: The expected location
+    def initialize(expected)
+      @expected = expected
+    end
+
+    # ==== Parameters
+    # target<Merb::Controller>:: The controller to match
+    #
+    # ==== Returns
+    # Boolean::
+    #   True if the controller status is redirect and the locations match.
+    def matches?(target)
+      @target, @location = target, target.headers['Location']
+      @redirected = BeRedirect.new.matches?(target.status)
+      @location == @expected && @redirected
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      msg = "expected #{inspect_target} to redirect to <#{@expected}>, but "
+      if @redirected
+        msg << "was <#{target_location}>" 
+      else
+        msg << "there was no redirection"
+      end
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected #{inspect_target} not to redirect to <#{@expected}>, but did anyway"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      "#{@target.controller_name}##{@target.action_name}"
+    end
+
+    # ==== Returns
+    # String:: Either the target's location header or the target itself.
+    def target_location
+      @target.respond_to?(:headers) ? @target.headers['Location'] : @target
+    end
+  end
+
+  class BeSuccess
+
+    # ==== Parameters
+    # target<Fixnum, ~status>::
+    #   Either the status code or a controller with a status code.
+    #
+    # ==== Returns
+    # Boolean:: True if the status code is in the range 200..207.
+    def matches?(target)
+      @target = target
+      (200..207).include?(status_code)
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected#{inspect_target} to be successful but was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected#{inspect_target} not to be successful but it was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      " #{@target.controller_name}##{@target.action_name}" if @target.respond_to?(:controller_name) && @target.respond_to?(:action_name)
+    end
+
+    # ==== Returns
+    # Fixnum:: Either the target's status or the target itself.
+    def status_code
+      @target.respond_to?(:status) ? @target.status : @target
+    end
+  end
+
+  class BeMissing
+
+    # ==== Parameters
+    # target<Fixnum, ~status>::
+    #   Either the status code or a controller with a status code.
+    #
+    # ==== Returns
+    # Boolean:: True if the status code is in the range 400..417.
+    def matches?(target)
+      @target = target
+      (400..417).include?(status_code)
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected#{inspect_target} to be missing but was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected#{inspect_target} not to be missing but it was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      " #{@target.controller_name}##{@target.action_name}" if @target.respond_to?(:controller_name) && @target.respond_to?(:action_name)
+    end
+
+    # ==== Returns
+    # Fixnum:: Either the target's status or the target itself.
+    def status_code
+      @target.respond_to?(:status) ? @target.status : @target
+    end
+  end
+
+  # Passes if the target was redirected, or the target is a redirection (300
+  # level) response code.
+  #
+  # ==== Examples
+  #   # Passes if the controller was redirected
+  #   controller.should redirect
+  #   
+  #   # Also works if the target is the response code
+  #   controller.status.should redirect
+  #
+  # ==== Notes
+  # valid HTTP Redirection codes:
+  # * 300: Multiple Choices
+  # * 301: Moved Permanently
+  # * 302: Moved Temporarily (HTTP/1.0)
+  # * 302: Found (HTTP/1.1)
+  # * 303: See Other (HTTP/1.1)
+  # * 304: Not Modified
+  # * 305: Use Proxy
+  # * 307: Temporary Redirect
+  #--
+  # status codes based on: http://cheat.errtheblog.com/s/http_status_codes/
+  def redirect
+    BeRedirect.new
+  end
+
+  alias_method :be_redirection, :redirect
+
+  # Passes if the target was redirected to the expected location.
+  #
+  # ==== Paramters
+  # expected<String>:: A relative or absolute url.
+  #
+  # ==== Examples
+  #   # Passes if the controller was redirected to http://example.com/
+  #   controller.should redirect_to('http://example.com/')
+  def redirect_to(expected)
+    RedirectTo.new(expected)
+  end
+
+  alias_method :be_redirection_to, :redirect_to
+
+  # Passes if the request that generated the target was successful, or the
+  # target is a success (200 level) response code.
+  #
+  # ==== Examples
+  #   # Passes if the controller call was successful
+  #   controller.should respond_successfully
+  #   
+  #   # Also works if the target is the response code
+  #   controller.status.should respond_successfully
+  #
+  # ==== Notes
+  # valid HTTP Success codes:
+  # * 200: OK
+  # * 201: Created
+  # * 202: Accepted
+  # * 203: Non-Authoritative Information
+  # * 204: No Content
+  # * 205: Reset Content
+  # * 206: Partial Content
+  # * 207: Multi-Status
+  #--
+  # status codes based on: http://cheat.errtheblog.com/s/http_status_codes/
+  def respond_successfully
+    BeSuccess.new
+  end
+
+  alias_method :be_successful, :respond_successfully
+
+  # Passes if the request that generated the target was missing, or the target
+  # is a client-side error (400 level) response code.
+  #
+  # ==== Examples
+  #   # Passes if the controller call was unknown or not understood
+  #   controller.should be_missing
+  #   
+  #   # Also passes if the target is a response code
+  #   controller.status.should be_missing
+  #
+  # ==== Notes
+  # valid HTTP Client Error codes:
+  # * 400: Bad Request
+  # * 401: Unauthorized
+  # * 402: Payment Required
+  # * 403: Forbidden
+  # * 404: Not Found
+  # * 405: Method Not Allowed
+  # * 406: Not Acceptable
+  # * 407: Proxy Authentication Required
+  # * 408: Request Timeout
+  # * 409: Conflict
+  # * 410: Gone
+  # * 411: Length Required
+  # * 412: Precondition Failed
+  # * 413: Request Entity Too Large
+  # * 414: Request-URI Too Long
+  # * 415: Unsupported Media Type
+  # * 416: Requested Range Not Satisfiable
+  # * 417: Expectation Failed
+  # * 422: Unprocessable Entity
+  #--
+  # status codes based on: http://cheat.errtheblog.com/s/http_status_codes/
+  def be_missing
+    BeMissing.new
+  end
+
+  alias_method :be_client_error, :be_missing
+end