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 append_charset? 

def append_charset?
  !@sending_file && @charset != false
end

def assign_default_content_type_and_charset!(headers) 

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

def await_commit 

def await_commit
  synchronize do
    @cv.wait_until { @committed }
  end
end

def body

of any calls to render.
Returns the content of the response as a string. This contains the contents 
def body
  strings = []
  each { |part| strings << part.to_s }
  strings.join
end

def body=(body)

Allows you to manually set or override the response body. 
def body=(body)
  @blank = true if body == EMPTY
  if body.respond_to?(:to_path)
    @stream = body
  else
    synchronize do
      @stream = build_buffer self, munge_body_object(body)
    end
  end
end

def body_parts 

def body_parts
  parts = []
  @stream.each { |x| parts << x }
  parts
end

def build_buffer(response, body) 

def build_buffer(response, body)
  Buffer.new response, body
end

def close 

def close
  stream.close if stream.respond_to?(:close)
end

def code

Returns a string to ensure compatibility with Net::HTTPResponse. 
def code
  @status.to_s
end

def commit! 

def commit!
  synchronize do
    @committed = true
    @cv.broadcast
  end
end

def committed? 

def committed?
  @committed
end

def content_type=(content_type) 

def content_type=(content_type)
  @content_type = content_type.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 = [])
  super()
  header = merge_default_headers(header, self.class.default_headers)
  self.body, self.header, self.status = body, header, status
  @sending_file = false
  @blank        = false
  @cv           = new_cond
  @committed    = false
  @content_type = nil
  @charset      = nil
  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 merge_default_headers(original, default) 

def merge_default_headers(original, default)
  return original unless default.respond_to?(:merge)
  default.merge(original)
end

def message


response.message # => "Not Found"
response.status = 404

response.message # => "OK"
response.status = 200

Returns the corresponding message for the current HTTP status code: 
def message
  Rack::Utils::HTTP_STATUS_CODES[@status]
end

def munge_body_object(body) 

def munge_body_object(body)
  body.respond_to?(:each) ? body : [body]
end

def rack_response(status, header) 

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

def respond_to?(method) 

def respond_to?(method)
  if method.to_s == 'to_path'
    stream.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)

Sets the HTTP status code. 
def status=(status)
  @status = Rack::Utils.status_code(status)
end

def to_a 

def to_a
  rack_response @status, @header.to_hash
end

def to_path 

def to_path
  stream.to_path
end