class ActionDispatch::Response

end
end
puts @response.body
get(‘/’)
def test_print_root_path_to_console
class DemoControllerTest < ActionDispatch::IntegrationTest
controller response to the console:
For example, the following demo integration test prints the body of the
TestResponse (which are of course also of type Response).
ActionDispatch::Integration::Session#post return objects of type
ActionDispatch::Integration::Session#get and
developers. Integration test methods such as
more detail, and that’s when Response can be useful for application
Nevertheless, integration tests may want to inspect controller responses in
ActionControllerBase#headers instead of Response#headers.
to set the HTTP response’s content MIME type, then use
methods defined in ActionController::Base instead. For example, if you want
should never be used directly in controllers. Controllers should use the
Response is mostly a Ruby on Rails framework implementation detail, and
from integration tests).
back to the web browser) or a TestResponse (i.e. one that is generated
either represent a real HTTP response (i.e. one that is meant to be sent
retrieve the current state of the response, or customize the response. It can
Represents an HTTP response generated by a controller action. Use it to
:nodoc:

def assign_default_content_type_and_charset!

def assign_default_content_type_and_charset!
  return if headers[CONTENT_TYPE].present?
  @content_type ||= Mime::HTML
  @charset      ||= self.class.default_charset
  type = @content_type.to_s.dup
  type << "; charset=#{@charset}" unless @sending_file
  headers[CONTENT_TYPE] = type
end

def body

def body
  strings = []
  each { |part| strings << part.to_s }
  strings.join
end

def body=(body)

def body=(body)
  @blank = true if body == EMPTY
  # Explicitly check for strings. This is *wrong* theoretically
  # but if we don't check this, the performance on string bodies
  # is bad on Ruby 1.8 (because strings responds to each then).
  @body = if body.respond_to?(:to_str) || !body.respond_to?(:each)
    [body]
  else
    body
  end
end

def body_parts

def body_parts
  @body
end

def close

def close
  @body.close if @body.respond_to?(:close)
end

def code

Returns a String to ensure compatibility with Net::HTTPResponse

def code
  @status.to_s
end

def cookies

assert_equal 'AuthorOfNewPage', r.cookies['author']

Returns the response cookies, converted to a Hash of (name => value) pairs

def cookies
  cookies = {}
  if header = self[SET_COOKIE]
    header = header.split("\n") if header.respond_to?(:to_str)
    header.each do |cookie|
      if pair = cookie.split(';').first
        key, value = pair.split("=").map { |v| Rack::Utils.unescape(v) }
        cookies[key] = value
      end
    end
  end
  cookies
end

def delete_cookie(key, value={})

def delete_cookie(key, value={})
  ::Rack::Utils.delete_cookie_header!(header, key, value)
end

def initialize(status = 200, header = {}, body = [])

def initialize(status = 200, header = {}, body = [])
  self.body, self.header, self.status = body, header, status
  @sending_file = false
  @blank = false
  if content_type = self[CONTENT_TYPE]
    type, charset = content_type.split(/;\s*charset=/)
    @content_type = Mime::Type.lookup(type)
    @charset = charset || self.class.default_charset
  end
  prepare_cache_control!
  yield self if block_given?
end

def location

def location
  headers[LOCATION]
end

def location=(url)

def location=(url)
  headers[LOCATION] = url
end

def message

def message
  Rack::Utils::HTTP_STATUS_CODES[@status]
end

def respond_to?(method)

def respond_to?(method)
  if method.to_sym == :to_path
    @body.respond_to?(:to_path)
  else
    super
  end
end

def response_code

The response code of the request

def response_code
  @status
end

def set_cookie(key, value)

def set_cookie(key, value)
  ::Rack::Utils.set_cookie_header!(header, key, value)
end

def status=(status)

def status=(status)
  @status = Rack::Utils.status_code(status)
end

def to_a

def to_a
  assign_default_content_type_and_charset!
  handle_conditional_get!
  @header[SET_COOKIE] = @header[SET_COOKIE].join("\n") if @header[SET_COOKIE].respond_to?(:join)
  if [204, 304].include?(@status)
    @header.delete CONTENT_TYPE
    [@status, @header, []]
  else
    [@status, @header, self]
  end
end

def to_path

def to_path
  @body.to_path
end

Modules

Classes