# class Rack::MockRequest

`Rack::MockRequest` helps testing your `Rack` application without actually using HTTP.

After performing a request on a URL with get/post/put/patch/delete, it returns a `MockResponse` with useful helper methods for effective testing.

You can pass a hash with additional configuration to the get/post/put/patch/delete.

`:input`

  A String or IO-like to be used as rack.input.

`:fatal`

  Raise a `FatalWarning` if the app writes to rack.errors.

`:lint`

  If true, wrap the application in a `Rack::Lint`.

### Constants

DEFAULT_ENV

### Public Class Methods

env_for(uri = "", opts = {}) click to toggle source

Return the `Rack` environment used for a request to `uri`. All options that are strings are added to the returned environment. Options:

:fatal

  Whether to raise an exception if request outputs to rack.errors

:input

  The rack.input to set

:method

  The HTTP request method to use

:params

  The params to use

:script_name

  The SCRIPT_NAME to set

    # File lib/rack/mock.rb, line 104
    def self.env_for(uri = "", opts = {})
      uri = parse_uri_rfc2396(uri)
      uri.path = "/#{uri.path}" unless uri.path[0] == ?/

      env = DEFAULT_ENV.dup

      env[REQUEST_METHOD]  = (opts[:method] ? opts[:method].to_s.upcase : GET).b
      env[SERVER_NAME]     = (uri.host || "example.org").b
      env[SERVER_PORT]     = (uri.port ? uri.port.to_s : "80").b
      env[QUERY_STRING]    = (uri.query.to_s).b
      env[PATH_INFO]       = ((!uri.path || uri.path.empty?) ? "/" : uri.path).b
      env[RACK_URL_SCHEME] = (uri.scheme || "http").b
      env[HTTPS]           = (env[RACK_URL_SCHEME] == "https" ? "on" : "off").b

      env[SCRIPT_NAME] = opts[:script_name] || ""

      if opts[:fatal]
        env[RACK_ERRORS] = FatalWarner.new
      else
        env[RACK_ERRORS] = StringIO.new
      end

      if params = opts[:params]
        if env[REQUEST_METHOD] == GET
          params = Utils.parse_nested_query(params) if params.is_a?(String)
          params.update(Utils.parse_nested_query(env[QUERY_STRING]))
          env[QUERY_STRING] = Utils.build_nested_query(params)
        elsif !opts.has_key?(:input)
          opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
          if params.is_a?(Hash)
            if data = Rack::Multipart.build_multipart(params)
              opts[:input] = data
              opts["CONTENT_LENGTH"] ||= data.length.to_s
              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Rack::Multipart::MULTIPART_BOUNDARY}"
            else
              opts[:input] = Utils.build_nested_query(params)
            end
          else
            opts[:input] = params
          end
        end
      end

      empty_str = String.new
      opts[:input] ||= empty_str
      if String === opts[:input]
        rack_input = StringIO.new(opts[:input])
      else
        rack_input = opts[:input]
      end

      rack_input.set_encoding(Encoding::BINARY)
      env[RACK_INPUT] = rack_input

      env["CONTENT_LENGTH"] ||= env[RACK_INPUT].size.to_s if env[RACK_INPUT].respond_to?(:size)

      opts.each { |field, value|
        env[field] = value  if String === field
      }

      env
    end

new(app) click to toggle source

    # File lib/rack/mock.rb, line 51
    def initialize(app)
      @app = app
    end

parse_uri_rfc2396(uri) click to toggle source

For historical reasons, we're pinning to RFC 2396. URI::Parser = URI::RFC2396_Parser

    # File lib/rack/mock.rb, line 91
    def self.parse_uri_rfc2396(uri)
      @parser ||= URI::Parser.new
      @parser.parse(uri)
    end

### Public Instance Methods

delete(uri, opts = {}) click to toggle source

Make a DELETE request and return a `MockResponse`. See `request`.

    # File lib/rack/mock.rb, line 64
    def delete(uri, opts = {})  request(DELETE, uri, opts)  end

get(uri, opts = {}) click to toggle source

Make a GET request and return a `MockResponse`. See `request`.

    # File lib/rack/mock.rb, line 56
    def get(uri, opts = {})     request(GET, uri, opts)     end

head(uri, opts = {}) click to toggle source

Make a HEAD request and return a `MockResponse`. See `request`.

    # File lib/rack/mock.rb, line 66
    def head(uri, opts = {})    request(HEAD, uri, opts)    end

options(uri, opts = {}) click to toggle source

Make an OPTIONS request and return a `MockResponse`. See `request`.

    # File lib/rack/mock.rb, line 68
    def options(uri, opts = {}) request(OPTIONS, uri, opts) end

patch(uri, opts = {}) click to toggle source

Make a PATCH request and return a `MockResponse`. See `request`.

    # File lib/rack/mock.rb, line 62
    def patch(uri, opts = {})   request(PATCH, uri, opts)   end

post(uri, opts = {}) click to toggle source

Make a POST request and return a `MockResponse`. See `request`.

    # File lib/rack/mock.rb, line 58
    def post(uri, opts = {})    request(POST, uri, opts)    end

put(uri, opts = {}) click to toggle source

Make a PUT request and return a `MockResponse`. See `request`.

    # File lib/rack/mock.rb, line 60
    def put(uri, opts = {})     request(PUT, uri, opts)     end

request(method = GET, uri = "", opts = {}) click to toggle source

Make a request using the given request method for the given uri to the rack application and return a `MockResponse`. Options given are passed to `MockRequest.env_for`.

    # File lib/rack/mock.rb, line 73
    def request(method = GET, uri = "", opts = {})
      env = self.class.env_for(uri, opts.merge(method: method))

      if opts[:lint]
        app = Rack::Lint.new(@app)
      else
        app = @app
      end

      errors = env[RACK_ERRORS]
      status, headers, body = app.call(env)
      MockResponse.new(status, headers, body, errors)
    ensure
      body.close if body.respond_to?(:close)
    end