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 abort

def abort
  if stream.respond_to?(:abort)
    stream.abort
  elsif stream.respond_to?(:close)
    # `stream.close` should really be reserved for a close from the
    # other direction, but we must fall back to it for
    # compatibility.
    stream.close
  end
end

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 await_sent

def await_sent
  synchronize { @cv.wait_until { @sent } }
end

def before_committed

def before_committed
end

def before_sending

def before_sending
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
    before_committed
    @committed = true
    @cv.broadcast
  end
end

def committed?; synchronize { @committed }; end

def committed?; synchronize { @committed }; end

def content_type=(content_type)

Sets the HTTP 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 = [], options = {})

def initialize(status = 200, header = {}, body = [], options = {})
  super()
  default_headers = options.fetch(:default_headers, self.class.default_headers)
  header = merge_default_headers(header, default_headers)
  self.body, self.header, self.status = body, header, status
  @sending_file = false
  @blank        = false
  @cv           = new_cond
  @committed    = false
  @sending      = false
  @sent         = 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

The location header we'll be responding with.

def location
  headers[LOCATION]
end

def location=(url)

Sets the location header we'll be responding with.

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

def merge_default_headers(original, default)

def merge_default_headers(original, default)
  default.respond_to?(:merge) ? default.merge(original) : 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, RackBody.new(self)]
  end
end

def response_code

The response code of the request.

def response_code
  @status
end

def sending!

def sending!
  synchronize do
    before_sending
    @sending = true
    @cv.broadcast
  end
end

def sending?; synchronize { @sending }; end

def sending?;   synchronize { @sending };   end

def sent!

def sent!
  synchronize do
    @sent = true
    @cv.broadcast
  end
end

def sent?; synchronize { @sent }; end

def sent?;      synchronize { @sent };      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

status, headers, body = *response

and body. Allows explict splatting:
Turns the Response into a Rack-compatible array of the status, headers,

def to_a
  rack_response @status, @header.to_hash
end

def to_ary

Not sensible behavior.
as arrays work, and "flattening" responses, cascading to the rack body!
would make implicit splatting work, but it also makes adding responses
Be super clear that a response object is not an Array. Defining this

def to_ary
  ActiveSupport::Deprecation.warn(<<-MSG.squish)
    `ActionDispatch::Response#to_ary` no longer performs implicit conversion
    to an array. Please use `response.to_a` instead, or a splat like `status,
    headers, body = *response`.
  MSG
  to_a
end