usher 0.7.0 → 0.7.1

data/spec/rails2_2/vendor/rails/vendor/rails/actionpack/lib/action_controller/status_codes.rb

@@ -1,88 +0,0 @@
-module ActionController
-  module StatusCodes #:nodoc:
-    # Defines the standard HTTP status codes, by integer, with their
-    # corresponding default message texts.
-    # Source: http://www.iana.org/assignments/http-status-codes
-    STATUS_CODES = {
-      100 => "Continue",
-      101 => "Switching Protocols",
-      102 => "Processing",
-
-      200 => "OK",
-      201 => "Created",
-      202 => "Accepted",
-      203 => "Non-Authoritative Information",
-      204 => "No Content",
-      205 => "Reset Content",
-      206 => "Partial Content",
-      207 => "Multi-Status",
-      226 => "IM Used",
-
-      300 => "Multiple Choices",
-      301 => "Moved Permanently",
-      302 => "Found",
-      303 => "See Other",
-      304 => "Not Modified",
-      305 => "Use Proxy",
-      307 => "Temporary Redirect",
-
-      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",
-      423 => "Locked",
-      424 => "Failed Dependency",
-      426 => "Upgrade Required",
-
-      500 => "Internal Server Error",
-      501 => "Not Implemented",
-      502 => "Bad Gateway",
-      503 => "Service Unavailable",
-      504 => "Gateway Timeout",
-      505 => "HTTP Version Not Supported",
-      507 => "Insufficient Storage",
-      510 => "Not Extended"
-    }
-
-    # Provides a symbol-to-fixnum lookup for converting a symbol (like
-    # :created or :not_implemented) into its corresponding HTTP status
-    # code (like 200 or 501).
-    SYMBOL_TO_STATUS_CODE = STATUS_CODES.inject({}) do |hash, (code, message)|
-      hash[message.gsub(/ /, "").underscore.to_sym] = code
-      hash
-    end
-
-    # Given a status parameter, determine whether it needs to be converted
-    # to a string. If it is a fixnum, use the STATUS_CODES hash to lookup
-    # the default message. If it is a symbol, use the SYMBOL_TO_STATUS_CODE
-    # hash to convert it.
-    def interpret_status(status)
-      case status
-      when Fixnum then
-        "#{status} #{STATUS_CODES[status]}".strip
-      when Symbol then
-        interpret_status(SYMBOL_TO_STATUS_CODE[status] ||
-          "500 Unknown Status #{status.inspect}")
-      else
-        status.to_s
-      end
-    end
-    private :interpret_status
-
-  end
-end

data/spec/rails2_2/vendor/rails/vendor/rails/actionpack/lib/action_controller/streaming.rb

@@ -1,162 +0,0 @@
-module ActionController #:nodoc:
-  # Methods for sending files and streams to the browser instead of rendering.
-  module Streaming
-    DEFAULT_SEND_FILE_OPTIONS = {
-      :type         => 'application/octet-stream'.freeze,
-      :disposition  => 'attachment'.freeze,
-      :stream       => true,
-      :buffer_size  => 4096,
-      :x_sendfile   => false
-    }.freeze
-
-    X_SENDFILE_HEADER = 'X-Sendfile'.freeze
-
-    protected
-      # Sends the file, by default streaming it 4096 bytes at a time. This way the
-      # whole file doesn't need to be read into memory at once. This makes it
-      # feasible to send even large files. You can optionally turn off streaming
-      # and send the whole file at once.
-      #
-      # Be careful to sanitize the path parameter if it is coming from a web
-      # page. <tt>send_file(params[:path])</tt> allows a malicious user to
-      # download any file on your server.
-      #
-      # Options:
-      # * <tt>:filename</tt> - suggests a filename for the browser to use.
-      #   Defaults to <tt>File.basename(path)</tt>.
-      # * <tt>:type</tt> - specifies an HTTP content type. Defaults to 'application/octet-stream'.
-      # * <tt>:length</tt> - used to manually override the length (in bytes) of the content that
-      #   is going to be sent to the client. Defaults to <tt>File.size(path)</tt>.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.
-      #   Valid values are 'inline' and 'attachment' (default).
-      # * <tt>:stream</tt> - whether to send the file to the user agent as it is read (+true+)
-      #   or to read the entire file before sending (+false+). Defaults to +true+.
-      # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used to stream the file.
-      #   Defaults to 4096.
-      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
-      # * <tt>:url_based_filename</tt> - set to +true+ if you want the browser guess the filename from
-      #   the URL, which is necessary for i18n filenames on certain browsers
-      #   (setting <tt>:filename</tt> overrides this option).
-      # * <tt>:x_sendfile</tt> - uses X-Sendfile to send the file when set to +true+. This is currently
-      #   only available with Lighttpd/Apache2 and specific modules installed and activated. Since this
-      #   uses the web server to send the file, this may lower memory consumption on your server and
-      #   it will not block your application for further requests.
-      #   See http://blog.lighttpd.net/articles/2006/07/02/x-sendfile and
-      #   http://tn123.ath.cx/mod_xsendfile/ for details. Defaults to +false+.
-      #
-      # The default Content-Type and Content-Disposition headers are
-      # set to download arbitrary binary files in as many browsers as
-      # possible.  IE versions 4, 5, 5.5, and 6 are all known to have
-      # a variety of quirks (especially when downloading over SSL).
-      #
-      # Simple download:
-      #
-      #   send_file '/path/to.zip'
-      #
-      # Show a JPEG in the browser:
-      #
-      #   send_file '/path/to.jpeg', :type => 'image/jpeg', :disposition => 'inline'
-      #
-      # Show a 404 page in the browser:
-      #
-      #   send_file '/path/to/404.html', :type => 'text/html; charset=utf-8', :status => 404
-      #
-      # Read about the other Content-* HTTP headers if you'd like to
-      # provide the user with more information (such as Content-Description) in
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11.
-      #
-      # Also be aware that the document may be cached by proxies and browsers.
-      # The Pragma and Cache-Control headers declare how the file may be cached
-      # by intermediaries.  They default to require clients to validate with
-      # the server before releasing cached responses.  See
-      # http://www.mnot.net/cache_docs/ for an overview of web caching and
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
-      # for the Cache-Control header spec.
-      def send_file(path, options = {}) #:doc:
-        raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
-
-        options[:length]   ||= File.size(path)
-        options[:filename] ||= File.basename(path) unless options[:url_based_filename]
-        send_file_headers! options
-
-        @performed_render = false
-
-        if options[:x_sendfile]
-          logger.info "Sending #{X_SENDFILE_HEADER} header #{path}" if logger
-          head options[:status], X_SENDFILE_HEADER => path
-        else
-          if options[:stream]
-            render :status => options[:status], :text => Proc.new { |response, output|
-              logger.info "Streaming file #{path}" unless logger.nil?
-              len = options[:buffer_size] || 4096
-              File.open(path, 'rb') do |file|
-                while buf = file.read(len)
-                  output.write(buf)
-                end
-              end
-            }
-          else
-            logger.info "Sending file #{path}" unless logger.nil?
-            File.open(path, 'rb') { |file| render :status => options[:status], :text => file.read }
-          end
-        end
-      end
-
-      # Send binary data to the user as a file download.  May set content type, apparent file name,
-      # and specify whether to show data inline or download as an attachment.
-      #
-      # Options:
-      # * <tt>:filename</tt> - suggests a filename for the browser to use.
-      # * <tt>:type</tt> - specifies an HTTP content type. Defaults to 'application/octet-stream'.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.
-      #   Valid values are 'inline' and 'attachment' (default).
-      # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
-      #
-      # Generic data download:
-      #
-      #   send_data buffer
-      #
-      # Download a dynamically-generated tarball:
-      #
-      #   send_data generate_tgz('dir'), :filename => 'dir.tgz'
-      #
-      # Display an image Active Record in the browser:
-      #
-      #   send_data image.data, :type => image.content_type, :disposition => 'inline'
-      #
-      # See +send_file+ for more information on HTTP Content-* headers and caching.
-      def send_data(data, options = {}) #:doc:
-        logger.info "Sending data #{options[:filename]}" if logger
-        send_file_headers! options.merge(:length => data.size)
-        @performed_render = false
-        render :status => options[:status], :text => data
-      end
-
-    private
-      def send_file_headers!(options)
-        options.update(DEFAULT_SEND_FILE_OPTIONS.merge(options))
-        [:length, :type, :disposition].each do |arg|
-          raise ArgumentError, ":#{arg} option required" if options[arg].nil?
-        end
-
-        disposition = options[:disposition].dup || 'attachment'
-
-        disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
-
-        headers.update(
-          'Content-Length'            => options[:length],
-          'Content-Type'              => options[:type].to_s.strip,  # fixes a problem with extra '\r' with some browsers
-          'Content-Disposition'       => disposition,
-          'Content-Transfer-Encoding' => 'binary'
-        )
-
-        # Fix a problem with IE 6.0 on opening downloaded files:
-        # If Cache-Control: no-cache is set (which Rails does by default),
-        # IE removes the file it just downloaded from its cache immediately
-        # after it displays the "open/save" dialog, which means that if you
-        # hit "open" the file isn't there anymore when the application that
-        # is called for handling the download is run, so let's workaround that
-        headers['Cache-Control'] = 'private' if headers['Cache-Control'] == 'no-cache'
-      end
-  end
-end

data/spec/rails2_2/vendor/rails/vendor/rails/actionpack/lib/action_controller/test_case.rb

@@ -1,147 +0,0 @@
-require 'active_support/test_case'
-
-module ActionController
-  class NonInferrableControllerError < ActionControllerError
-    def initialize(name)
-      @name = name
-      super "Unable to determine the controller to test from #{name}. " +
-        "You'll need to specify it using 'tests YourController' in your " +
-        "test case definition. This could mean that #{inferred_controller_name} does not exist " +
-        "or it contains syntax errors"
-    end
-
-    def inferred_controller_name
-      @name.sub(/Test$/, '')
-    end
-  end
-
-  # Superclass for ActionController functional tests. Functional tests allow you to
-  # test a single controller action per test method. This should not be confused with
-  # integration tests (see ActionController::IntegrationTest), which are more like
-  # "stories" that can involve multiple controllers and mutliple actions (i.e. multiple
-  # different HTTP requests).
-  #
-  # == Basic example
-  #
-  # Functional tests are written as follows:
-  # 1. First, one uses the +get+, +post+, +put+, +delete+ or +head+ method to simulate
-  #    an HTTP request.
-  # 2. Then, one asserts whether the current state is as expected. "State" can be anything:
-  #    the controller's HTTP response, the database contents, etc.
-  #
-  # For example:
-  #
-  #   class BooksControllerTest < ActionController::TestCase
-  #     def test_create
-  #       # Simulate a POST response with the given HTTP parameters.
-  #       post(:create, :book => { :title => "Love Hina" })
-  #
-  #       # Assert that the controller tried to redirect us to
-  #       # the created book's URI.
-  #       assert_response :found
-  #
-  #       # Assert that the controller really put the book in the database.
-  #       assert_not_nil Book.find_by_title("Love Hina")
-  #     end
-  #   end
-  #
-  # == Special instance variables
-  #
-  # ActionController::TestCase will also automatically provide the following instance
-  # variables for use in the tests:
-  #
-  # <b>@controller</b>::
-  #      The controller instance that will be tested.
-  # <b>@request</b>::
-  #      An ActionController::TestRequest, representing the current HTTP
-  #      request. You can modify this object before sending the HTTP request. For example,
-  #      you might want to set some session properties before sending a GET request.
-  # <b>@response</b>::
-  #      An ActionController::TestResponse object, representing the response
-  #      of the last HTTP response. In the above example, <tt>@response</tt> becomes valid
-  #      after calling +post+. If the various assert methods are not sufficient, then you
-  #      may use this object to inspect the HTTP response in detail.
-  #
-  # (Earlier versions of Rails required each functional test to subclass
-  # Test::Unit::TestCase and define @controller, @request, @response in +setup+.)
-  #
-  # == Controller is automatically inferred
-  #
-  # ActionController::TestCase will automatically infer the controller under test
-  # from the test class name. If the controller cannot be inferred from the test
-  # class name, you can explicity set it with +tests+.
-  #
-  #   class SpecialEdgeCaseWidgetsControllerTest < ActionController::TestCase
-  #     tests WidgetController
-  #   end
-  class TestCase < ActiveSupport::TestCase
-    # When the request.remote_addr remains the default for testing, which is 0.0.0.0, the exception is simply raised inline
-    # (bystepping the regular exception handling from rescue_action). If the request.remote_addr is anything else, the regular
-    # rescue_action process takes place. This means you can test your rescue_action code by setting remote_addr to something else
-    # than 0.0.0.0.
-    #
-    # The exception is stored in the exception accessor for further inspection.
-    module RaiseActionExceptions
-      attr_accessor :exception
-
-      def rescue_action_without_handler(e)
-        self.exception = e
-        
-        if request.remote_addr == "0.0.0.0"
-          raise(e)
-        else
-          super(e)
-        end
-      end
-    end
-
-    setup :setup_controller_request_and_response
-
-    @@controller_class = nil
-
-    class << self
-      # Sets the controller class name. Useful if the name can't be inferred from test class.
-      # Expects +controller_class+ as a constant. Example: <tt>tests WidgetController</tt>.
-      def tests(controller_class)
-        self.controller_class = controller_class
-      end
-
-      def controller_class=(new_class)
-        prepare_controller_class(new_class)
-        write_inheritable_attribute(:controller_class, new_class)
-      end
-
-      def controller_class
-        if current_controller_class = read_inheritable_attribute(:controller_class)
-          current_controller_class
-        else
-          self.controller_class = determine_default_controller_class(name)
-        end
-      end
-
-      def determine_default_controller_class(name)
-        name.sub(/Test$/, '').constantize
-      rescue NameError
-        raise NonInferrableControllerError.new(name)
-      end
-
-      def prepare_controller_class(new_class)
-        new_class.send :include, RaiseActionExceptions
-      end
-    end
-
-    def setup_controller_request_and_response
-      @controller = self.class.controller_class.new
-      @controller.request = @request = TestRequest.new
-      @response = TestResponse.new
-
-      @controller.params = {}
-      @controller.send(:initialize_current_url)
-    end
-    
-    # Cause the action to be rescued according to the regular rules for rescue_action when the visitor is not local
-    def rescue_action_in_public!
-      @request.remote_addr = '208.77.188.166' # example.com
-    end
- end
-end

data/spec/rails2_2/vendor/rails/vendor/rails/actionpack/lib/action_controller/test_process.rb

@@ -1,531 +0,0 @@
-require 'action_controller/assertions'
-require 'action_controller/test_case'
-
-module ActionController #:nodoc:
-  class Base
-    attr_reader :assigns
-
-    # Process a test request called with a TestRequest object.
-    def self.process_test(request)
-      new.process_test(request)
-    end
-
-    def process_test(request) #:nodoc:
-      process(request, TestResponse.new)
-    end
-
-    def process_with_test(*args)
-      returning process_without_test(*args) do
-        @assigns = {}
-        (instance_variable_names - @@protected_instance_variables).each do |var|
-          value = instance_variable_get(var)
-          @assigns[var[1..-1]] = value
-          response.template.assigns[var[1..-1]] = value if response
-        end
-      end
-    end
-
-    alias_method_chain :process, :test
-  end
-
-  class TestRequest < AbstractRequest #:nodoc:
-    attr_accessor :cookies, :session_options
-    attr_accessor :query_parameters, :request_parameters, :path, :session
-    attr_accessor :host, :user_agent
-
-    def initialize(query_parameters = nil, request_parameters = nil, session = nil)
-      @query_parameters   = query_parameters || {}
-      @request_parameters = request_parameters || {}
-      @session            = session || TestSession.new
-
-      initialize_containers
-      initialize_default_values
-
-      super()
-    end
-
-    def reset_session
-      @session = TestSession.new
-    end
-
-    # Wraps raw_post in a StringIO.
-    def body_stream #:nodoc:
-      StringIO.new(raw_post)
-    end
-
-    # Either the RAW_POST_DATA environment variable or the URL-encoded request
-    # parameters.
-    def raw_post
-      env['RAW_POST_DATA'] ||= returning(url_encoded_request_parameters) { |b| b.force_encoding(Encoding::BINARY) if b.respond_to?(:force_encoding) }
-    end
-
-    def port=(number)
-      @env["SERVER_PORT"] = number.to_i
-      port(true)
-    end
-
-    def action=(action_name)
-      @query_parameters.update({ "action" => action_name })
-      @parameters = nil
-    end
-
-    # Used to check AbstractRequest's request_uri functionality.
-    # Disables the use of @path and @request_uri so superclass can handle those.
-    def set_REQUEST_URI(value)
-      @env["REQUEST_URI"] = value
-      @request_uri = nil
-      @path = nil
-      request_uri(true)
-      path(true)
-    end
-
-    def request_uri=(uri)
-      @request_uri = uri
-      @path = uri.split("?").first
-    end
-
-    def accept=(mime_types)
-      @env["HTTP_ACCEPT"] = Array(mime_types).collect { |mime_types| mime_types.to_s }.join(",")
-      accepts(true)
-    end
-
-    def if_modified_since=(last_modified)
-      @env["HTTP_IF_MODIFIED_SINCE"] = last_modified
-    end
-
-    def if_none_match=(etag)
-      @env["HTTP_IF_NONE_MATCH"] = etag
-    end
-
-    def remote_addr=(addr)
-      @env['REMOTE_ADDR'] = addr
-    end
-
-    def request_uri(*args)
-      @request_uri || super
-    end
-
-    def path(*args)
-      @path || super
-    end
-
-    def assign_parameters(controller_path, action, parameters)
-      parameters = parameters.symbolize_keys.merge(:controller => controller_path, :action => action)
-      extra_keys = ActionController::Routing::Routes.extra_keys(parameters)
-      non_path_parameters = get? ? query_parameters : request_parameters
-      parameters.each do |key, value|
-        if value.is_a? Fixnum
-          value = value.to_s
-        elsif value.is_a? Array
-          value = ActionController::Routing::PathSegment::Result.new(value)
-        end
-
-        if extra_keys.include?(key.to_sym)
-          non_path_parameters[key] = value
-        else
-          path_parameters[key.to_s] = value
-        end
-      end
-      @parameters = nil # reset TestRequest#parameters to use the new path_parameters
-    end
-
-    def recycle!
-      self.request_parameters = {}
-      self.query_parameters   = {}
-      self.path_parameters    = {}
-      unmemoize_all
-    end
-
-    private
-      def initialize_containers
-        @env, @cookies = {}, {}
-      end
-
-      def initialize_default_values
-        @host                    = "test.host"
-        @request_uri             = "/"
-        @user_agent              = "Rails Testing"
-        self.remote_addr         = "0.0.0.0"
-        @env["SERVER_PORT"]      = 80
-        @env['REQUEST_METHOD']   = "GET"
-      end
-
-      def url_encoded_request_parameters
-        params = self.request_parameters.dup
-
-        %w(controller action only_path).each do |k|
-          params.delete(k)
-          params.delete(k.to_sym)
-        end
-
-        params.to_query
-      end
-  end
-
-  # A refactoring of TestResponse to allow the same behavior to be applied
-  # to the "real" CgiResponse class in integration tests.
-  module TestResponseBehavior #:nodoc:
-    # The response code of the request
-    def response_code
-      status[0,3].to_i rescue 0
-    end
-
-    # Returns a String to ensure compatibility with Net::HTTPResponse
-    def code
-      status.to_s.split(' ')[0]
-    end
-
-    def message
-      status.to_s.split(' ',2)[1]
-    end
-
-    # Was the response successful?
-    def success?
-      (200..299).include?(response_code)
-    end
-
-    # Was the URL not found?
-    def missing?
-      response_code == 404
-    end
-
-    # Were we redirected?
-    def redirect?
-      (300..399).include?(response_code)
-    end
-
-    # Was there a server-side error?
-    def error?
-      (500..599).include?(response_code)
-    end
-
-    alias_method :server_error?, :error?
-
-    # Returns the redirection location or nil
-    def redirect_url
-      headers['Location']
-    end
-
-    # Does the redirect location match this regexp pattern?
-    def redirect_url_match?( pattern )
-      return false if redirect_url.nil?
-      p = Regexp.new(pattern) if pattern.class == String
-      p = pattern if pattern.class == Regexp
-      return false if p.nil?
-      p.match(redirect_url) != nil
-    end
-
-    # Returns the template of the file which was used to
-    # render this response (or nil)
-    def rendered_template
-      template.instance_variable_get(:@_first_render)
-    end
-
-    # A shortcut to the flash. Returns an empty hash if no session flash exists.
-    def flash
-      session['flash'] || {}
-    end
-
-    # Do we have a flash?
-    def has_flash?
-      !session['flash'].empty?
-    end
-
-    # Do we have a flash that has contents?
-    def has_flash_with_contents?
-      !flash.empty?
-    end
-
-    # Does the specified flash object exist?
-    def has_flash_object?(name=nil)
-      !flash[name].nil?
-    end
-
-    # Does the specified object exist in the session?
-    def has_session_object?(name=nil)
-      !session[name].nil?
-    end
-
-    # A shortcut to the template.assigns
-    def template_objects
-      template.assigns || {}
-    end
-
-    # Does the specified template object exist?
-    def has_template_object?(name=nil)
-      !template_objects[name].nil?
-    end
-
-    # Returns the response cookies, converted to a Hash of (name => CGI::Cookie) pairs
-    #
-    #   assert_equal ['AuthorOfNewPage'], r.cookies['author'].value
-    def cookies
-      headers['cookie'].inject({}) { |hash, cookie| hash[cookie.name] = cookie; hash }
-    end
-
-    # Returns binary content (downloadable file), converted to a String
-    def binary_content
-      raise "Response body is not a Proc: #{body.inspect}" unless body.kind_of?(Proc)
-      require 'stringio'
-
-      sio = StringIO.new
-      body.call(self, sio)
-
-      sio.rewind
-      sio.read
-    end
-  end
-
-  # Integration test methods such as ActionController::Integration::Session#get
-  # and ActionController::Integration::Session#post return objects of class
-  # TestResponse, which represent the HTTP response results of the requested
-  # controller actions.
-  #
-  # See AbstractResponse for more information on controller response objects.
-  class TestResponse < AbstractResponse
-    include TestResponseBehavior
-    
-    def recycle!
-      headers.delete('ETag')
-      headers.delete('Last-Modified')
-    end
-  end
-
-  class TestSession #:nodoc:
-    attr_accessor :session_id
-
-    def initialize(attributes = nil)
-      @session_id = ''
-      @attributes = attributes.nil? ? nil : attributes.stringify_keys
-      @saved_attributes = nil
-    end
-
-    def data
-      @attributes ||= @saved_attributes || {}
-    end
-
-    def [](key)
-      data[key.to_s]
-    end
-
-    def []=(key, value)
-      data[key.to_s] = value
-    end
-
-    def update
-      @saved_attributes = @attributes
-    end
-
-    def delete
-      @attributes = nil
-    end
-
-    def close
-      update
-      delete
-    end
-  end
-
-  # Essentially generates a modified Tempfile object similar to the object
-  # you'd get from the standard library CGI module in a multipart
-  # request. This means you can use an ActionController::TestUploadedFile
-  # object in the params of a test request in order to simulate
-  # a file upload.
-  #
-  # Usage example, within a functional test:
-  #   post :change_avatar, :avatar => ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + '/files/spongebob.png', 'image/png')
-  #
-  # Pass a true third parameter to ensure the uploaded file is opened in binary mode (only required for Windows):
-  #   post :change_avatar, :avatar => ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + '/files/spongebob.png', 'image/png', :binary)
-  require 'tempfile'
-  class TestUploadedFile
-    # The filename, *not* including the path, of the "uploaded" file
-    attr_reader :original_filename
-
-    # The content type of the "uploaded" file
-    attr_accessor :content_type
-
-    def initialize(path, content_type = Mime::TEXT, binary = false)
-      raise "#{path} file does not exist" unless File.exist?(path)
-      @content_type = content_type
-      @original_filename = path.sub(/^.*#{File::SEPARATOR}([^#{File::SEPARATOR}]+)$/) { $1 }
-      @tempfile = Tempfile.new(@original_filename)
-      @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
-      @tempfile.binmode if binary
-      FileUtils.copy_file(path, @tempfile.path)
-    end
-
-    def path #:nodoc:
-      @tempfile.path
-    end
-
-    alias local_path path
-
-    def method_missing(method_name, *args, &block) #:nodoc:
-      @tempfile.__send__(method_name, *args, &block)
-    end
-  end
-
-  module TestProcess
-    def self.included(base)
-      # execute the request simulating a specific HTTP method and set/volley the response
-      # TODO: this should be un-DRY'ed for the sake of API documentation.
-      %w( get post put delete head ).each do |method|
-        base.class_eval <<-EOV, __FILE__, __LINE__
-          def #{method}(action, parameters = nil, session = nil, flash = nil)
-            @request.env['REQUEST_METHOD'] = "#{method.upcase}" if defined?(@request)
-            process(action, parameters, session, flash)
-          end
-        EOV
-      end
-    end
-
-    # execute the request and set/volley the response
-    def process(action, parameters = nil, session = nil, flash = nil)
-      # Sanity check for required instance variables so we can give an
-      # understandable error message.
-      %w(@controller @request @response).each do |iv_name|
-        if !(instance_variable_names.include?(iv_name) || instance_variable_names.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
-          raise "#{iv_name} is nil: make sure you set it in your test's setup method."
-        end
-      end
-
-      @request.recycle!
-      @response.recycle!
-
-      @html_document = nil
-      @request.env['REQUEST_METHOD'] ||= "GET"
-
-      @request.action = action.to_s
-
-      parameters ||= {}
-      @request.assign_parameters(@controller.class.controller_path, action.to_s, parameters)
-
-      @request.session = ActionController::TestSession.new(session) unless session.nil?
-      @request.session["flash"] = ActionController::Flash::FlashHash.new.update(flash) if flash
-      build_request_uri(action, parameters)
-      @controller.process(@request, @response)
-    end
-
-    def xml_http_request(request_method, action, parameters = nil, session = nil, flash = nil)
-      @request.env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
-      @request.env['HTTP_ACCEPT'] = 'text/javascript, text/html, application/xml, text/xml, */*'
-      returning __send__(request_method, action, parameters, session, flash) do
-        @request.env.delete 'HTTP_X_REQUESTED_WITH'
-        @request.env.delete 'HTTP_ACCEPT'
-      end
-    end
-    alias xhr :xml_http_request
-
-    def assigns(key = nil)
-      if key.nil?
-        @response.template.assigns
-      else
-        @response.template.assigns[key.to_s]
-      end
-    end
-
-    def session
-      @response.session
-    end
-
-    def flash
-      @response.flash
-    end
-
-    def cookies
-      @response.cookies
-    end
-
-    def redirect_to_url
-      @response.redirect_url
-    end
-
-    def build_request_uri(action, parameters)
-      unless @request.env['REQUEST_URI']
-        options = @controller.__send__(:rewrite_options, parameters)
-        options.update(:only_path => true, :action => action)
-
-        url = ActionController::UrlRewriter.new(@request, parameters)
-        @request.set_REQUEST_URI(url.rewrite(options))
-      end
-    end
-
-    def html_document
-      xml = @response.content_type =~ /xml$/
-      @html_document ||= HTML::Document.new(@response.body, false, xml)
-    end
-
-    def find_tag(conditions)
-      html_document.find(conditions)
-    end
-
-    def find_all_tag(conditions)
-      html_document.find_all(conditions)
-    end
-
-    def method_missing(selector, *args)
-      if ActionController::Routing::Routes.named_routes.helpers.include?(selector)
-        @controller.send(selector, *args)
-      else
-        super
-      end
-    end
-
-    # Shortcut for <tt>ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + path, type)</tt>:
-    #
-    #   post :change_avatar, :avatar => fixture_file_upload('/files/spongebob.png', 'image/png')
-    #
-    # To upload binary files on Windows, pass <tt>:binary</tt> as the last parameter.
-    # This will not affect other platforms:
-    #
-    #   post :change_avatar, :avatar => fixture_file_upload('/files/spongebob.png', 'image/png', :binary)
-    def fixture_file_upload(path, mime_type = nil, binary = false)
-      ActionController::TestUploadedFile.new(
-        Test::Unit::TestCase.respond_to?(:fixture_path) ? Test::Unit::TestCase.fixture_path + path : path,
-        mime_type,
-        binary
-      )
-    end
-
-    # A helper to make it easier to test different route configurations.
-    # This method temporarily replaces ActionController::Routing::Routes
-    # with a new RouteSet instance.
-    #
-    # The new instance is yielded to the passed block. Typically the block
-    # will create some routes using <tt>map.draw { map.connect ... }</tt>:
-    #
-    #   with_routing do |set|
-    #     set.draw do |map|
-    #       map.connect ':controller/:action/:id'
-    #         assert_equal(
-    #           ['/content/10/show', {}],
-    #           map.generate(:controller => 'content', :id => 10, :action => 'show')
-    #       end
-    #     end
-    #   end
-    #
-    def with_routing
-      real_routes = ActionController::Routing::Routes
-      ActionController::Routing.module_eval { remove_const :Routes }
-
-      temporary_routes = ActionController::Routing::RouteSet.new
-      ActionController::Routing.module_eval { const_set :Routes, temporary_routes }
-
-      yield temporary_routes
-    ensure
-      if ActionController::Routing.const_defined? :Routes
-        ActionController::Routing.module_eval { remove_const :Routes }
-      end
-      ActionController::Routing.const_set(:Routes, real_routes) if real_routes
-    end
-  end
-end
-
-module Test
-  module Unit
-    class TestCase #:nodoc:
-      include ActionController::TestProcess
-    end
-  end
-end