thorero 0.9.4.4 → 0.9.4.5

data/lib/merb-core/tasks/audit.rake

@@ -0,0 +1,68 @@
+namespace :audit do
+
+  desc "Print out the named and anonymous routes"
+  task :routes => :merb_env do
+    seen = []
+    unless Merb::Router.named_routes.empty?
+      puts "Named Routes"
+      Merb::Router.named_routes.each do |name,route|
+        puts "  #{name}: #{route}"
+        seen << route
+      end
+    end
+    puts "Anonymous Routes"
+    (Merb::Router.routes - seen).each do |route|
+      puts "  #{route}"
+    end
+    nil
+  end
+
+  desc "Print out all controllers"
+  task :controllers => :merb_env do
+    puts "\nControllers:\n\n"
+    abstract_controller_classes.each do |klass|
+      if klass.respond_to?(:subclasses_list)
+        puts "#{klass} < #{klass.superclass}"
+        subklasses = klass.subclasses_list.sort.map { |x| Object.full_const_get(x) }
+        unless subklasses.empty?
+          subklasses.each { |subklass| puts "- #{subklass}" }
+        else
+          puts "~ no subclasses"
+        end
+        puts
+      end
+    end
+  end
+  
+  desc "Print out controllers and their actions (use CONTROLLER=Foo,Bar to be selective)"
+  task :actions => :merb_env do
+    puts "\nControllers and their actions:\n\n"
+    filter_controllers = ENV['CONTROLLER'] ? ENV['CONTROLLER'].split(',') : nil
+    abstract_controllers = abstract_controller_classes
+    classes = Merb::AbstractController.subclasses_list.sort.map { |x| Object.full_const_get(x) }
+    classes = classes.select { |k| k.name.in?(filter_controllers) } if filter_controllers
+    classes.each do |subklass|
+      next if subklass.in?(abstract_controllers) || !subklass.respond_to?(:callable_actions)
+      puts "#{subklass} < #{subklass.superclass}"
+      unless subklass.callable_actions.empty?
+        subklass.callable_actions.sort.each do |action, null|
+          if subklass.respond_to?(:action_argument_list)
+            arguments, defaults = subklass.action_argument_list[action]
+            args = arguments.map { |name, value| value ? "#{name} = #{value.inspect}" : name.to_s }.join(', ')
+            puts args.empty? ? "- #{action}" : "- #{action}(#{args})"
+          else
+            puts "- #{action}"
+          end
+        end
+      else
+        puts "~ no callable actions"
+      end
+      puts
+    end    
+  end
+  
+  def abstract_controller_classes
+    ObjectSpace.classes.select { |x| x.superclass == Merb::AbstractController }.sort_by { |x| x.name }
+  end
+  
+end

data/lib/merb-core/tasks/merb.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) / '*.rake'].each { |ext| load ext }

data/lib/merb-core/tasks/merb_rake_helper.rb

@@ -0,0 +1,12 @@
+def sudo
+  ENV['MERB_SUDO'] ||= "sudo"
+  sudo = windows? ? "" : ENV['MERB_SUDO']
+end
+
+def windows?
+  (PLATFORM =~ /win32|cygwin/) rescue nil
+end
+
+def install_home
+  ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+end

data/lib/merb-core/test.rb

@@ -0,0 +1,11 @@
+require "hpricot"
+
+require 'merb-core/test/test_ext/hpricot'
+require 'merb-core/test/test_ext/object'
+require 'merb-core/test/test_ext/string'
+
+module Merb; module Test; end; end
+
+require 'merb-core/test/helpers'
+
+require 'merb-core/test/matchers'

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

@@ -0,0 +1,9 @@
+# This is a place holder to allow plugins etc a place to include 
+# testing helpers
+module Merb::Test::Helpers; end
+
+require "merb-core/test/helpers/request_helper"
+require "merb-core/test/helpers/multipart_request_helper"
+require "merb-core/test/helpers/controller_helper"
+require "merb-core/test/helpers/route_helper"
+require "merb-core/test/helpers/view_helper"

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

@@ -0,0 +1,8 @@
+module Merb
+  module Test
+    module ControllerHelper
+      include RequestHelper
+      include MultipartRequestHelper
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+module Merb::Test::MultipartRequestHelper
+  require 'rubygems'
+  require 'mime/types'
+
+  class Param
+    attr_accessor :key, :value
+
+    # ==== Parameters
+    # key<~to_s>:: The parameter key.
+    # value<~to_s>:: The parameter value.
+    def initialize(key, value)
+      @key   = key
+      @value = value
+    end
+
+    # ==== Returns
+    # String:: The parameter in a form suitable for a multipart request.
+    def to_multipart
+      return %(Content-Disposition: form-data; name="#{key}"\r\n\r\n#{value}\r\n)
+    end
+  end
+
+  class FileParam
+    attr_accessor :key, :filename, :content
+
+    # ==== Parameters
+    # key<~to_s>:: The parameter key.
+    # filename<~to_s>:: Name of the file for this parameter.
+    # content<~to_s>:: Content of the file for this parameter.
+    def initialize(key, filename, content)
+      @key      = key
+      @filename = filename
+      @content  = content
+    end
+
+    # ==== Returns
+    # String::
+    #   The file parameter in a form suitable for a multipart request.
+    def to_multipart
+      return %(Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r\n) + "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" + content + "\r\n"
+    end
+  end
+
+  class Post
+    BOUNDARY = '----------0xKhTmLbOuNdArY'
+    CONTENT_TYPE = "multipart/form-data, boundary=" + BOUNDARY
+
+    # ==== Parameters
+    # params<Hash>:: Optional params for the controller.
+    def initialize(params = {})
+      @multipart_params = []
+      push_params(params)
+    end
+
+    # Saves the params in an array of multipart params as Param and
+    # FileParam objects.
+    #
+    # ==== Parameters
+    # params<Hash>:: The params to add to the multipart params.
+    # prefix<~to_s>:: An optional prefix for the request string keys.
+    def push_params(params, prefix = nil)
+      params.sort_by {|k| k.to_s}.each do |key, value|
+        param_key = prefix.nil? ? key : "#{prefix}[#{key}]"
+        if value.respond_to?(:read)
+          @multipart_params << FileParam.new(param_key, value.path, value.read)
+        else
+          if value.is_a?(Hash) || value.is_a?(Mash)
+            value.keys.each do |k|
+              push_params(value, param_key)
+            end
+          else
+            @multipart_params << Param.new(param_key, value)
+          end
+        end
+      end
+    end
+
+    # ==== Returns
+    # Array[String, String]:: The query and the content type.
+    def to_multipart
+      query = @multipart_params.collect { |param| "--" + BOUNDARY + "\r\n" + param.to_multipart }.join("") + "--" + BOUNDARY + "--"
+      return query, CONTENT_TYPE
+    end
+  end 
+
+  # Similar to dispatch_to but allows for sending files inside params.  
+  #
+  # ==== Paramters 
+  # 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+).
+  # &blk:: The block is executed in the context of the controller.
+  #  
+  # ==== Example
+  #   dispatch_multipart_to(MyController, :create, :my_file => @a_file ) do |controller|
+  #     controller.stub!(:current_user).and_return(@user)
+  #   end
+  #
+  # ==== Notes
+  # Set your option to contain a file object to simulate file uploads.
+  #   
+  # Does not use routes.
+  #---
+  # @public
+  def dispatch_multipart_to(controller_klass, action, params = {}, env = {}, &blk)
+    request = multipart_fake_request(env, params)
+    dispatch_request(request, controller_klass, action, &blk)
+  end
+
+  # An HTTP POST request that operates through the router and uses multipart
+  # parameters.
+  #
+  # ==== 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<Proc>:: The block is executed in the context of the controller.
+  #
+  # ==== Notes
+  # To include an uploaded file, put a file object as a value in params.
+  def multipart_post(path, params = {}, env = {}, &block)
+    env[:request_method] = "POST"
+    env[:test_with_multipart] = true
+    request(path, params, env, &block)
+  end
+
+  # An HTTP PUT request that operates through the router and uses multipart
+  # parameters.
+  #
+  # ==== 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<Proc>:: The block is executed in the context of the controller.
+  #
+  # ==== Notes
+  # To include an uplaoded file, put a file object as a value in params.
+  def multipart_put(path, params = {}, env = {}, &block)
+    env[:request_method] = "PUT"
+    env[:test_with_multipart] = true
+    request(path, params, env, &block)
+  end
+  
+  # ==== Parameters
+  # env<Hash>::
+  #   An optional hash that is passed to the fake request. Any request options
+  #   should go here (see +fake_request+).
+  # params<Hash>::
+  #   An optional hash that will end up as params in the controller instance.
+  # 
+  # ==== Returns
+  # FakeRequest::
+  #   A multipart Request object that is built based on the parameters.
+  def multipart_fake_request(env = {}, params = {})
+    if params.empty?
+      fake_request(env)
+    else
+      m = Post.new(params)
+      body, head = m.to_multipart
+      fake_request(env.merge( :content_type => head, 
+                              :content_length => body.length), :post_body => body)
+    end
+  end
+end

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

@@ -0,0 +1,344 @@
+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.
+      #
+      # ==== Notes
+      # 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 |controller|
+      #     controller.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public
+      def dispatch_to(controller_klass, action, params = {}, env = {}, &blk)
+        dispatch_request(build_request(params, env), controller_klass, action.to_s, &blk)
+      end
+
+
+      # Dispatches an action to the given class and using HTTP Basic Authentication
+      # 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.
+      # username<String>:: The username.
+      # password<String>:: The password.
+      # 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_with_basic_authentication_to(MyController, :create, 'Fred', 'secret', :name => 'Homer' ) do |controller|
+      #     controller.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public
+      def dispatch_with_basic_authentication_to(controller_klass, action, username, password, params = {}, env = {}, &blk)
+        env["X_HTTP_AUTHORIZATION"] = "Basic #{Base64.encode64("#{username}:#{password}")}"
+        
+        dispatch_request(build_request(params, env), controller_klass, action.to_s, &blk)
+      end
+
+      # Prepares and returns a request suitable for dispatching with
+      # dispatch_request. If you don't need to modify the request
+      # object before dispatching (e.g. to add cookies), you probably
+      # want to use dispatch_to instead.
+      #
+      # ==== Parameters
+      # 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.
+      #
+      # ==== Example
+      #   req = build_request(:id => 1)
+      #   req.cookies['app_cookie'] = "testing"
+      #   dispatch_request(req, MyController, :edit)
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public      
+      def build_request(params = {}, env = {})
+        params             = Merb::Request.params_to_query_string(params)
+        env[:query_string] = env["QUERY_STRING"] ? "#{env["QUERY_STRING"]}&#{params}" : params
+        
+        fake_request(env, { :post_body => env[:post_body], :req => env[:req] })
+      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+).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public      
+      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).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public      
+      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).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public      
+      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).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public
+      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::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Example
+      #   request(path, { :name => 'Homer' }, { :request_method => "PUT" }) do |controller|
+      #     controller.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Notes
+      # Uses Routes.
+      #
+      #---
+      # @semi-public
+      def request(path, params = {}, env= {}, &block)
+        env[:request_method] ||= "GET"
+        env[:request_uri], env[:query_string] = path.split('?')
+        
+        multipart = env.delete(:test_with_multipart)
+
+        request = fake_request(env)
+
+        opts = check_request_for_route(request) # Check that the request will be routed correctly
+        controller_name = (opts[:namespace] ? opts.delete(:namespace) + '/' : '') + opts.delete(:controller)
+        klass = Object.full_const_get(controller_name.snake_case.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::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Returns
+      # An instance of +controller_klass+ based on the parameters.
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public
+      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.
+      #
+      #---
+      # @semi-public
+      def check_request_for_route(request)
+        match =  ::Merb::Router.match(request)
+        if match[0].nil? && match[1].empty?
+          raise ::Merb::ControllerExceptions::BadRequest, "No routes match the request"
+        else
+          match[1]
+        end
+      end # check_request_for_route
+    end # RequestHelper
+  end # Test
+end # Merb