An instance of this class represents a set of requests and responses performed sequentially by a test process. Because you can instantiate multiple sessions and run them side-by-side, you can also mimic (to some limited extent) multiple simultaneous users interacting with your system.

Typically, you will instantiate a new session using IntegrationTest#open_session, rather than instantiating Integration::Session directly.

Methods

Included Modules

Constants

DEFAULT_HOST = "www.example.com"

Attributes

[RW] accept

The Accept header to send.
[R] controller

A reference to the controller instance used by the last request.
[W] host
[W] host!
[RW] remote_addr

The remote_addr used in the last request.
[R] request

A reference to the request instance used by the last request.
[RW] request_count

A running counter of the number of requests processed.
[R] response

A reference to the response instance used by the last request.

Class Public methods

new(app)

Create and initialize a new Session instance.

📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 116
      def initialize(app)
        super()
        @app = app

        reset!
      end
🔎 See on GitHub

Instance Public methods

cookies()

A map of the cookies returned by the last response, and which will be sent with the next request.

📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 97
      def cookies
        _mock_session.cookie_jar
      end
🔎 See on GitHub

host()

The hostname used in the last request.

📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 84
      def host
        @host || DEFAULT_HOST
      end
🔎 See on GitHub

https!(flag = true)

Specify whether or not the session should mimic a secure HTTPS request.

session.https!
session.https!(false)
📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 164
      def https!(flag = true)
        @https = flag
      end
🔎 See on GitHub

https?()

Returns true if the session is mimicking a secure HTTPS request.

if session.https?
  ...
end
📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 173
      def https?
        @https
      end
🔎 See on GitHub

process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: nil)

Performs the actual request.

  • method: The HTTP method (GET, POST, PATCH, PUT, DELETE, HEAD, OPTIONS) as a symbol.

  • path: The URI (as a String) on which you want to perform the request.

  • params: The HTTP parameters that you want to pass. This may be nil, a Hash, or a String that is appropriately encoded (application/x-www-form-urlencoded or multipart/form-data).

  • headers: Additional headers to pass, as a Hash. The headers will be merged into the Rack env hash.

  • env: Additional env to pass, as a Hash. The headers will be merged into the Rack env hash.

This method is rarely used directly. Use #get, #post, or other standard HTTP methods in integration tests. #process is only required when using a request method that doesn't have a method defined in the integration tests.

This method returns the response status, after performing the request. Furthermore, if this method was called from an ActionDispatch::IntegrationTest object, then that object's @response instance variable will point to a Response object which one can use to inspect the details of the response.

Example:

process :get, '/author', params: { since: 201501011400 }
📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 204
      def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: nil)
        request_encoder = RequestEncoder.encoder(as)
        headers ||= {}

        if method == :get && as == :json && params
          headers["X-Http-Method-Override"] = "GET"
          method = :post
        end

        if path =~ %r{://}
          path = build_expanded_path(path) do |location|
            https! URI::HTTPS === location if location.scheme

            if url_host = location.host
              default = Rack::Request::DEFAULT_PORTS[location.scheme]
              url_host += ":#{location.port}" if default != location.port
              host! url_host
            end
          end
        end

        hostname, port = host.split(":")

        request_env = {
          :method => method,
          :params => request_encoder.encode_params(params),

          "SERVER_NAME"     => hostname,
          "SERVER_PORT"     => port || (https? ? "443" : "80"),
          "HTTPS"           => https? ? "on" : "off",
          "rack.url_scheme" => https? ? "https" : "http",

          "REQUEST_URI"    => path,
          "HTTP_HOST"      => host,
          "REMOTE_ADDR"    => remote_addr,
          "CONTENT_TYPE"   => request_encoder.content_type,
          "HTTP_ACCEPT"    => request_encoder.accept_header || accept
        }

        wrapped_headers = Http::Headers.from_hash({})
        wrapped_headers.merge!(headers) if headers

        if xhr
          wrapped_headers["HTTP_X_REQUESTED_WITH"] = "XMLHttpRequest"
          wrapped_headers["HTTP_ACCEPT"] ||= [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(", ")
        end

        # This modifies the passed request_env directly.
        if wrapped_headers.present?
          Http::Headers.from_hash(request_env).merge!(wrapped_headers)
        end
        if env.present?
          Http::Headers.from_hash(request_env).merge!(env)
        end

        session = Rack::Test::Session.new(_mock_session)

        # NOTE: rack-test v0.5 doesn't build a default uri correctly
        # Make sure requested path is always a full URI.
        session.request(build_full_uri(path, request_env), request_env)

        @request_count += 1
        @request = ActionDispatch::Request.new(session.last_request.env)
        response = _mock_session.last_response
        @response = ActionDispatch::TestResponse.from_response(response)
        @response.request = @request
        @html_document = nil
        @url_options = nil

        @controller = @request.controller_instance

        response.status
      end
🔎 See on GitHub

reset!()

Resets the instance. This can be used to reset the state information in an existing session instance, so it can be used from a clean-slate condition.

session.reset!
📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 140
      def reset!
        @https = false
        @controller = @request = @response = nil
        @_mock_session = nil
        @request_count = 0
        @url_options = nil

        self.host        = DEFAULT_HOST
        self.remote_addr = "127.0.0.1"
        self.accept      = "text/xml,application/xml,application/xhtml+xml," \
                           "text/html;q=0.9,text/plain;q=0.8,image/png," \
                           "*/*;q=0.5"

        unless defined? @named_routes_configured
          # the helpers are made protected by default--we make them public for
          # easier access during testing and troubleshooting.
          @named_routes_configured = true
        end
      end
🔎 See on GitHub

url_options()

📝 Source code 
# File actionpack/lib/action_dispatch/testing/integration.rb, line 123
      def url_options
        @url_options ||= default_url_options.dup.tap do |url_options|
          url_options.reverse_merge!(controller.url_options) if controller

          if @app.respond_to?(:routes)
            url_options.reverse_merge!(@app.routes.default_url_options)
          end

          url_options.reverse_merge!(host: host, protocol: https? ? "https" : "http")
        end
      end
🔎 See on GitHub