rack-test 0.2.0 → 0.3.0

data/History.txt

@@ -1,3 +1,20 @@
+== 0.3.0 / 2009-05-17
+
+* Major enhancements
+
+  * Ruby 1.9 compatible (Simon Rozet, Michael Fellinger)
+
+* Minor enhancements
+
+  * Add CookieJar#[] and CookieJar#[]= methods
+  * Make the default host configurable
+  * Use Rack::Lint and fix errors (Simon Rozet)
+  * Extract Rack::MockSession from Rack::Test::Session to handle tracking
+    the last request and response and the cookie jar
+  * Add #set_cookie and #clear_cookies methods
+  * Rename #authorize to #basic_authorize (#authorize remains as an alias)
+    (Simon Rozet)
+
 == 0.2.0 / 2009-04-26
 
 Because #last_response is now a MockResponse instead of a Rack::Response,

data/lib/rack/mock_session.rb

@@ -0,0 +1,50 @@
+module Rack
+
+  class MockSession
+    attr_writer :cookie_jar
+    attr_reader :last_response
+
+    def initialize(app, default_host = Rack::Test::DEFAULT_HOST)
+      @app = app
+      @default_host = default_host
+    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)
+      cookie_jar.merge(last_response.headers["Set-Cookie"], uri)
+
+      @last_response
+    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

@@ -4,7 +4,9 @@ end
 
 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"
@@ -12,44 +14,25 @@ require "rack/test/uploaded_file"
 module Rack
   module Test
 
-    class MockDigestRequest
-      def initialize(params)
-        @params = params
-      end
-
-      def method_missing(sym)
-        if @params.has_key? k = sym.to_s
-          return @params[k]
-        end
-
-        super
-      end
-
-      def method
-        @params['method']
-      end
-
-      def response(password)
-        Rack::Auth::Digest::MD5.new(nil).send :digest, self, password
-      end
-    end
-
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
 
+    DEFAULT_HOST = "example.org"
     MULTIPART_BOUNDARY = "----------XnJLe9ZIbbGUYtzPQJ16u1"
 
     # The common base class for exceptions raised by Rack::Test
     class Error < StandardError; end
 
     class Session
+      extend Forwardable
       include Rack::Test::Utils
 
-      # Initialize a new session for the given Rack app
-      def initialize(app)
-        raise ArgumentError.new("app must respond_to?(:call)") unless app.respond_to?(:call)
+      def_delegators :@rack_mock_session, :clear_cookies, :set_cookie, :last_response, :last_request
 
+      # Initialize a new session for the given Rack app
+      def initialize(app, default_host = DEFAULT_HOST)
         @headers = {}
-        @app     = app
+        @default_host = default_host
+        @rack_mock_session = Rack::MockSession.new(app, default_host)
       end
 
       # Issue a GET request for the given URI with the given params and Rack
@@ -129,12 +112,14 @@ module Rack
       # included in subsequent requests in the HTTP_AUTHORIZATION header.
       #
       # Example:
-      #   authorize "bryan", "secret"
-      def authorize(username, password)
+      #   basic_authorize "bryan", "secret"
+      def basic_authorize(username, password)
         encoded_login = ["#{username}:#{password}"].pack("m*")
         header('HTTP_AUTHORIZATION', "Basic #{encoded_login}")
       end
 
+      alias_method :authorize, :basic_authorize
+
       def digest_authorize(username, password)
         @digest_username = username
         @digest_password = password
@@ -151,27 +136,11 @@ module Rack
         get(last_response["Location"])
       end
 
-      # Return the last request issued in the session. Raises an error if no
-      # requests have been sent yet.
-      def last_request
-        raise 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 Error.new("No response yet. Request a page first.") unless @last_response
-
-        @last_response
-      end
-
     private
 
       def env_for(path, env)
         uri = URI.parse(path)
-        uri.host ||= "example.org"
+        uri.host ||= @default_host
 
         env = default_env.merge(env)
 
@@ -181,9 +150,8 @@ module Rack
         if (env[:method] == "POST" || env["REQUEST_METHOD"] == "POST") && !env.has_key?(:input)
           env["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
 
-          multipart = (env[:params] || {}).any? do |k, v|
-            UploadedFile === v
-          end
+          multipart = (Hash === env[:params]) &&
+            env[:params].any? { |_, v| UploadedFile === v }
 
           if multipart
             env[:input] = multipart_body(env.delete(:params))
@@ -200,61 +168,51 @@ module Rack
         uri.query = requestify(params)
 
         if env.has_key?(:cookie)
-          # Add the cookies explicitly set by the user
-          env["HTTP_COOKIE"] = cookie_jar.merge(uri, env.delete(:cookie)).for(uri)
-        else
-          env["HTTP_COOKIE"] = cookie_jar.for(uri)
+          set_cookie(env.delete(:cookie), uri)
         end
 
         Rack::MockRequest.env_for(uri.to_s, env)
       end
 
-      def cookie_jar
-        @cookie_jar || Rack::Test::CookieJar.new
-      end
-
       def process_request(uri, env)
         uri = URI.parse(uri)
-        uri.host ||= "example.org"
-
-        @last_request = Rack::Request.new(env)
-
-        status, headers, body = @app.call(@last_request.env)
-        @last_response = MockResponse.new(status, headers, body, env["rack.errors"])
+        uri.host ||= @default_host
 
-        @cookie_jar = cookie_jar.merge(uri, last_response.headers["Set-Cookie"])
+        @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 = 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?
+          yield last_response if block_given?
 
-          @last_response
+          last_response
         end
       end
 
       def digest_auth_header
-        challenge = @last_response["WWW-Authenticate"].split(" ", 2).last
+        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.path_info,
-          "method"    => @last_request.env["REQUEST_METHOD"],
+          "uri"       => last_request.path_info,
+          "method"    => last_request.env["REQUEST_METHOD"],
         })
 
         params["response"] = MockDigestRequest.new(params).response(@digest_password)
 
-        return "Digest #{params}"
+        "Digest #{params}"
       end
 
       def retry_with_digest_auth?(env)
-        @last_response.status == 401 &&
+        last_response.status == 401 &&
         digest_auth_configured? &&
         !env["rack-test.digest_auth_retry"]
       end

data/lib/rack/test/cookie_jar.rb

@@ -1,3 +1,4 @@
+require "uri"
 module Rack
   module Test
 
@@ -8,16 +9,22 @@ module Rack
       attr_reader :name, :value
 
       # :api: private
-      def initialize(raw, default_host)
+      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.delete_if { |k, v| !v || v.empty? }
+        @options["domain"]  ||= (uri.host || default_host)
+        @options["path"]    ||= uri.path.sub(/\/[^\/]*\Z/, "")
+      end
 
-        @options["domain"] ||= default_host
+      def replaces?(other)
+        [name.downcase, domain, path] == [other.name.downcase, other.domain, other.path]
       end
 
       # :api: private
@@ -35,9 +42,13 @@ module Rack
         @options["domain"]
       end
 
+      def secure?
+        @options.has_key?("secure")
+      end
+
       # :api: private
       def path
-        @options["path"] || "/"
+        @options["path"].strip || "/"
       end
 
       # :api: private
@@ -52,7 +63,14 @@ module Rack
 
       # :api: private
       def valid?(uri)
-        uri.host =~ Regexp.new("#{Regexp.escape(domain)}$") &&
+        uri ||= default_uri
+
+        if uri.host.nil?
+          uri.host = @default_host
+        end
+
+        (!secure? || (secure? && uri.scheme == "https")) &&
+        uri.host =~ Regexp.new("#{Regexp.escape(domain)}$", Regexp::IGNORECASE) &&
         uri.path =~ Regexp.new("^#{Regexp.escape(path)}")
       end
 
@@ -67,40 +85,70 @@ module Rack
         [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
       end
 
+    protected
+
+      def default_uri
+        URI.parse("//" + @default_host + "/")
+      end
+
     end
 
     class CookieJar
 
       # :api: private
-      def initialize(cookies = [])
-        @jar = cookies
-        @jar.sort!
+      def initialize(cookies = [], default_host = DEFAULT_HOST)
+        @default_host = default_host
+        @cookies = cookies
+        @cookies.sort!
       end
 
-      def merge(uri, raw_cookies)
-        return self unless raw_cookies
+      def [](name)
+        cookies = hash_for(nil)
+        # TODO: Should be case insensitive
+        cookies[name] && cookies[name].value
+      end
 
-        # Initialize all the the received cookies
-        cookies = []
-        raw_cookies.each do |raw|
-          c = Cookie.new(raw, uri.host)
-          cookies << c if c.valid?(uri)
-        end
+      def []=(name, value)
+        # TODO: needs proper escaping
+        merge("#{name}=#{value}")
+      end
 
-        # Remove all the cookies that will be updated
-        new_jar = @jar.reject do |existing|
-          cookies.find do |c|
-            [c.name, c.domain, c.path] == [existing.name, existing.domain, existing.path]
-          end
+      def merge(raw_cookies, uri = nil)
+        return unless raw_cookies
+
+        raw_cookies.each_line do |raw_cookie|
+          cookie = Cookie.new(raw_cookie, uri, @default_host)
+          self << cookie if cookie.valid?(uri)
         end
+      end
 
-        new_jar.concat cookies
+      def <<(new_cookie)
+        @cookies.reject! do |existing_cookie|
+          new_cookie.replaces?(existing_cookie)
+        end
 
-        return self.class.new(new_jar)
+        @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
@@ -108,11 +156,11 @@ module Rack
         # 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.
-        @jar.each do |cookie|
-          cookies[cookie.name] = cookie.raw if cookie.matches?(uri)
+        @cookies.each do |cookie|
+          cookies[cookie.name] = cookie if cookie.matches?(uri)
         end
 
-        cookies.values.join(';')
+        return cookies
       end
 
     end

data/lib/rack/test/methods.rb

@@ -9,20 +9,31 @@ module Rack
         @_rack_test_session ||= Rack::Test::Session.new(app)
       end
 
+      def rack_mock_session
+        @_rack_mock_session ||= Rack::MockSession.new(app)
+      end
+
       METHODS = [
         :request,
+
         # HTTP verbs
         :get,
         :post,
         :put,
         :delete,
         :head,
+
         # Redirects
         :follow_redirect!,
+
         # Header-related features
         :header,
+        :set_cookie,
+        :clear_cookies,
         :authorize,
+        :basic_authorize,
         :digest_authorize,
+
         # Expose the last request and response
         :last_response,
         :last_request

data/lib/rack/test/mock_digest_request.rb

@@ -0,0 +1,27 @@
+module Rack
+  module Test
+
+    class MockDigestRequest
+      def initialize(params)
+        @params = params
+      end
+
+      def method_missing(sym)
+        if @params.has_key? k = sym.to_s
+          return @params[k]
+        end
+
+        super
+      end
+
+      def method
+        @params['method']
+      end
+
+      def response(password)
+        Rack::Auth::Digest::MD5.new(nil).send :digest, self, password
+      end
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-test
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Bryan Helmkamp
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-26 00:00:00 -04:00
+date: 2009-05-17 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -26,16 +26,18 @@ files:
 - History.txt
 - Rakefile
 - README.rdoc
-- lib/rack
-- lib/rack/test
+- lib/rack/mock_session.rb
 - lib/rack/test/cookie_jar.rb
 - lib/rack/test/methods.rb
+- lib/rack/test/mock_digest_request.rb
 - lib/rack/test/uploaded_file.rb
 - lib/rack/test/utils.rb
 - lib/rack/test.rb
 - MIT-LICENSE.txt
 has_rdoc: true
 homepage: http://github.com/brynary/rack-test
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -56,9 +58,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Simple testing API built on Rack
 test_files: []