joebadmo-rack-test 0.6.1

data/lib/rack/mock_session.rb

@@ -0,0 +1,66 @@
+module Rack
+
+  class MockSession # :nodoc:
+    attr_writer :cookie_jar
+    attr_reader :default_host
+
+    def initialize(app, default_host = Rack::Test::DEFAULT_HOST)
+      @app = app
+      @after_request = []
+      @default_host = default_host
+      @last_request = nil
+      @last_response = nil
+    end
+
+    def after_request(&block)
+      @after_request << block
+    end
+
+    def clear_cookies
+      @cookie_jar = Rack::Test::CookieJar.new([], @default_host)
+    end
+
+    def set_cookie(cookie, uri = nil)
+      cookie_jar.merge(cookie, uri)
+    end
+
+    def request(uri, env)
+      env["HTTP_COOKIE"] ||= cookie_jar.for(uri)
+      @last_request = Rack::Request.new(env)
+      status, headers, body = @app.call(@last_request.env)
+
+      @last_response = MockResponse.new(status, headers, body, env["rack.errors"].flush)
+      body.close if body.respond_to?(:close)
+
+      cookie_jar.merge(last_response.headers["Set-Cookie"], uri)
+
+      @after_request.each { |hook| hook.call }
+
+      if @last_response.respond_to?(:finish)
+        @last_response.finish
+      else
+        @last_response
+      end
+    end
+
+    # Return the last request issued in the session. Raises an error if no
+    # requests have been sent yet.
+    def last_request
+      raise Rack::Test::Error.new("No request yet. Request a page first.") unless @last_request
+      @last_request
+    end
+
+    # Return the last response received in the session. Raises an error if
+    # no requests have been sent yet.
+    def last_response
+      raise Rack::Test::Error.new("No response yet. Request a page first.") unless @last_response
+      @last_response
+    end
+
+    def cookie_jar
+      @cookie_jar ||= Rack::Test::CookieJar.new([], @default_host)
+    end
+
+  end
+
+end

data/lib/rack/test.rb

@@ -0,0 +1,302 @@
+require "uri"
+require "rack"
+require "rack/mock_session"
+require "rack/test/cookie_jar"
+require "rack/test/mock_digest_request"
+require "rack/test/utils"
+require "rack/test/methods"
+require "rack/test/uploaded_file"
+
+module Rack
+  module Test
+    VERSION = "0.6.1"
+
+    DEFAULT_HOST = "example.org"
+    MULTIPART_BOUNDARY = "----------XnJLe9ZIbbGUYtzPQJ16u1"
+
+    # The common base class for exceptions raised by Rack::Test
+    class Error < StandardError; end
+
+    # This class represents a series of requests issued to a Rack app, sharing
+    # a single cookie jar
+    #
+    # Rack::Test::Session's methods are most often called through Rack::Test::Methods,
+    # which will automatically build a session when it's first used.
+    class Session
+      extend Forwardable
+      include Rack::Test::Utils
+
+      def_delegators :@rack_mock_session, :clear_cookies, :set_cookie, :last_response, :last_request
+
+      # Creates a Rack::Test::Session for a given Rack app or Rack::MockSession.
+      #
+      # Note: Generally, you won't need to initialize a Rack::Test::Session directly.
+      # Instead, you should include Rack::Test::Methods into your testing context.
+      # (See README.rdoc for an example)
+      def initialize(mock_session)
+        @headers = {}
+
+        if mock_session.is_a?(MockSession)
+          @rack_mock_session = mock_session
+        else
+          @rack_mock_session = MockSession.new(mock_session)
+        end
+
+        @default_host = @rack_mock_session.default_host
+      end
+
+      # Issue a GET request for the given URI with the given params and Rack
+      # environment. Stores the issues request object in #last_request and
+      # the app's response in #last_response. Yield #last_response to a block
+      # if given.
+      #
+      # Example:
+      #   get "/"
+      def get(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "GET", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a POST request for the given URI. See #get
+      #
+      # Example:
+      #   post "/signup", "name" => "Bryan"
+      def post(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "POST", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a PUT request for the given URI. See #get
+      #
+      # Example:
+      #   put "/"
+      def put(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "PUT", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a PATCH request for the given URI. See #get
+      #
+      # Example:
+      #   patch "/"
+      def patch(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "PATCH", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a DELETE request for the given URI. See #get
+      #
+      # Example:
+      #   delete "/"
+      def delete(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "DELETE", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue an OPTIONS request for the given URI. See #get
+      #
+      # Example:
+      #   options "/"
+      def options(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "OPTIONS", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a HEAD request for the given URI. See #get
+      #
+      # Example:
+      #   head "/"
+      def head(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "HEAD", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a request to the Rack app for the given URI and optional Rack
+      # environment. Stores the issues request object in #last_request and
+      # the app's response in #last_response. Yield #last_response to a block
+      # if given.
+      #
+      # Example:
+      #   request "/"
+      def request(uri, env = {}, &block)
+        env = env_for(uri, env)
+        process_request(uri, env, &block)
+      end
+
+      # Set a header to be included on all subsequent requests through the
+      # session. Use a value of nil to remove a previously configured header.
+      #
+      # In accordance with the Rack spec, headers will be included in the Rack
+      # environment hash in HTTP_USER_AGENT form.
+      #
+      # Example:
+      #   header "User-Agent", "Firefox"
+      def header(name, value)
+        if value.nil?
+          @headers.delete(name)
+        else
+          @headers[name] = value
+        end
+      end
+
+      # Set the username and password for HTTP Basic authorization, to be
+      # included in subsequent requests in the HTTP_AUTHORIZATION header.
+      #
+      # Example:
+      #   basic_authorize "bryan", "secret"
+      def basic_authorize(username, password)
+        encoded_login = ["#{username}:#{password}"].pack("m*")
+        header('Authorization', "Basic #{encoded_login}")
+      end
+
+      alias_method :authorize, :basic_authorize
+
+      # Set the username and password for HTTP Digest authorization, to be
+      # included in subsequent requests in the HTTP_AUTHORIZATION header.
+      #
+      # Example:
+      #   digest_authorize "bryan", "secret"
+      def digest_authorize(username, password)
+        @digest_username = username
+        @digest_password = password
+      end
+
+      # Rack::Test will not follow any redirects automatically. This method
+      # will follow the redirect returned (including setting the Referer header
+      # on the new request) in the last response. If the last response was not
+      # a redirect, an error will be raised.
+      def follow_redirect!
+        unless last_response.redirect?
+          raise Error.new("Last response was not a redirect. Cannot follow_redirect!")
+        end
+
+        get(last_response["Location"], {}, { "HTTP_REFERER" => last_request.url })
+      end
+
+    private
+
+      def env_for(path, env)
+        uri = URI.parse(path)
+        uri.path = "/#{uri.path}" unless uri.path[0] == ?/
+        uri.host ||= @default_host
+
+        env = default_env.merge(env)
+
+        env["HTTP_HOST"] ||= [uri.host, uri.port].compact.join(":")
+
+        env.update("HTTPS" => "on") if URI::HTTPS === uri
+        env["HTTP_X_REQUESTED_WITH"] = "XMLHttpRequest" if env[:xhr]
+
+        # TODO: Remove this after Rack 1.1 has been released.
+        # Stringifying and upcasing methods has be commit upstream
+        env["REQUEST_METHOD"] ||= env[:method] ? env[:method].to_s.upcase : "GET"
+
+        if env["REQUEST_METHOD"] == "GET"
+          params = env[:params] || {}
+          params = parse_nested_query(params) if params.is_a?(String)
+          params.update(parse_nested_query(uri.query))
+          uri.query = build_nested_query(params)
+        elsif !env.has_key?(:input)
+          env["CONTENT_TYPE"] ||= "application/x-www-form-urlencoded"
+
+          if env[:params].is_a?(Hash)
+            if data = build_multipart(env[:params])
+              env[:input] = data
+              env["CONTENT_LENGTH"] ||= data.length.to_s
+              env["CONTENT_TYPE"] = "multipart/form-data; boundary=#{MULTIPART_BOUNDARY}"
+            else
+              env[:input] = params_to_string(env[:params])
+            end
+          else
+            env[:input] = env[:params]
+          end
+        end
+
+        env.delete(:params)
+
+        if env.has_key?(:cookie)
+          set_cookie(env.delete(:cookie), uri)
+        end
+
+        Rack::MockRequest.env_for(uri.to_s, env)
+      end
+
+      def process_request(uri, env)
+        uri = URI.parse(uri)
+        uri.host ||= @default_host
+
+        @rack_mock_session.request(uri, env)
+
+        if retry_with_digest_auth?(env)
+          auth_env = env.merge({
+            "HTTP_AUTHORIZATION"          => digest_auth_header,
+            "rack-test.digest_auth_retry" => true
+          })
+          auth_env.delete('rack.request')
+          process_request(uri.path, auth_env)
+        else
+          yield last_response if block_given?
+
+          last_response
+        end
+      end
+
+      def digest_auth_header
+        challenge = last_response["WWW-Authenticate"].split(" ", 2).last
+        params = Rack::Auth::Digest::Params.parse(challenge)
+
+        params.merge!({
+          "username"  => @digest_username,
+          "nc"        => "00000001",
+          "cnonce"    => "nonsensenonce",
+          "uri"       => last_request.fullpath,
+          "method"    => last_request.env["REQUEST_METHOD"],
+        })
+
+        params["response"] = MockDigestRequest.new(params).response(@digest_password)
+
+        "Digest #{params}"
+      end
+
+      def retry_with_digest_auth?(env)
+        last_response.status == 401 &&
+        digest_auth_configured? &&
+        !env["rack-test.digest_auth_retry"]
+      end
+
+      def digest_auth_configured?
+        @digest_username
+      end
+
+      def default_env
+        { "rack.test" => true, "REMOTE_ADDR" => "127.0.0.1" }.merge(headers_for_env)
+      end
+
+      def headers_for_env
+        converted_headers = {}
+
+        @headers.each do |name, value|
+          env_key = name.upcase.gsub("-", "_")
+          env_key = "HTTP_" + env_key unless "CONTENT_TYPE" == env_key
+          converted_headers[env_key] = value
+        end
+
+        converted_headers
+      end
+
+      def params_to_string(params)
+        case params
+        when Hash then build_nested_query(params)
+        when nil  then ""
+        else params
+        end
+      end
+
+    end
+
+    def self.encoding_aware_strings?
+      defined?(Encoding) && "".respond_to?(:encode)
+    end
+
+  end
+end

data/lib/rack/test/cookie_jar.rb

@@ -0,0 +1,176 @@
+require "uri"
+require "time"
+
+module Rack
+  module Test
+
+    class Cookie # :nodoc:
+      include Rack::Utils
+
+      # :api: private
+      attr_reader :name, :value
+
+      # :api: private
+      def initialize(raw, uri = nil, default_host = DEFAULT_HOST)
+        @default_host = default_host
+        uri ||= default_uri
+
+        # separate the name / value pair from the cookie options
+        @name_value_raw, options = raw.split(/[;,] */n, 2)
+
+        @name, @value = parse_query(@name_value_raw, ';').to_a.first
+        @options = parse_query(options, ';')
+
+        @options["domain"]  ||= (uri.host || default_host)
+        @options["path"]    ||= uri.path.sub(/\/[^\/]*\Z/, "")
+      end
+
+      def replaces?(other)
+        [name.downcase, domain, path] == [other.name.downcase, other.domain, other.path]
+      end
+
+      # :api: private
+      def raw
+        @name_value_raw
+      end
+
+      # :api: private
+      def empty?
+        @value.nil? || @value.empty?
+      end
+
+      # :api: private
+      def domain
+        @options["domain"]
+      end
+
+      def secure?
+        @options.has_key?("secure")
+      end
+
+      # :api: private
+      def path
+        @options["path"].strip || "/"
+      end
+
+      # :api: private
+      def expires
+        Time.parse(@options["expires"]) if @options["expires"]
+      end
+
+      # :api: private
+      def expired?
+        expires && expires < Time.now
+      end
+
+      # :api: private
+      def valid?(uri)
+        uri ||= default_uri
+
+        if uri.host.nil?
+          uri.host = @default_host
+        end
+
+        real_domain = domain =~ /^\./ ? domain[1..-1] : domain
+        (!secure? || (secure? && uri.scheme == "https")) &&
+        uri.host =~ Regexp.new("#{Regexp.escape(real_domain)}$", Regexp::IGNORECASE) &&
+        uri.path =~ Regexp.new("^#{Regexp.escape(path)}")
+      end
+
+      # :api: private
+      def matches?(uri)
+        ! expired? && valid?(uri)
+      end
+
+      # :api: private
+      def <=>(other)
+        # Orders the cookies from least specific to most
+        [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
+      end
+
+    protected
+
+      def default_uri
+        URI.parse("//" + @default_host + "/")
+      end
+
+    end
+
+    class CookieJar # :nodoc:
+
+      # :api: private
+      def initialize(cookies = [], default_host = DEFAULT_HOST)
+        @default_host = default_host
+        @cookies = cookies
+        @cookies.sort!
+      end
+
+      def [](name)
+        cookies = hash_for(nil)
+        # TODO: Should be case insensitive
+        cookies[name] && cookies[name].value
+      end
+
+      def []=(name, value)
+        merge("#{name}=#{Rack::Utils.escape(value)}")
+      end
+
+      def merge(raw_cookies, uri = nil)
+        return unless raw_cookies
+
+        if raw_cookies.is_a? String
+          raw_cookies = raw_cookies.split("\n")
+          raw_cookies.reject!{|c| c.empty? }
+        end
+
+        raw_cookies.each do |raw_cookie|
+          cookie = Cookie.new(raw_cookie, uri, @default_host)
+          self << cookie if cookie.valid?(uri)
+        end
+      end
+
+      def <<(new_cookie)
+        @cookies.reject! do |existing_cookie|
+          new_cookie.replaces?(existing_cookie)
+        end
+
+        @cookies << new_cookie
+        @cookies.sort!
+      end
+
+      # :api: private
+      def for(uri)
+        hash_for(uri).values.map { |c| c.raw }.join(';')
+      end
+
+      def to_hash
+        cookies = {}
+
+        hash_for(nil).each do |name, cookie|
+          cookies[name] = cookie.value
+        end
+
+        return cookies
+      end
+
+    protected
+
+      def hash_for(uri = nil)
+        cookies = {}
+
+        # The cookies are sorted by most specific first. So, we loop through
+        # all the cookies in order and add it to a hash by cookie name if
+        # the cookie can be sent to the current URI. It's added to the hash
+        # so that when we are done, the cookies will be unique by name and
+        # we'll have grabbed the most specific to the URI.
+        @cookies.each do |cookie|
+          cookies[cookie.name] = cookie if !uri || cookie.matches?(uri)
+        end
+
+        return cookies
+      end
+
+    end
+
+  end
+end