rack-test 0.6.3 → 2.1.0

data/lib/rack/test/cookie_jar.rb

@@ -1,132 +1,191 @@
-require "uri"
-require "time"
+# frozen_string_literal: true
+
+require 'uri'
+require 'time'
 
 module Rack
   module Test
-
+    # Represents individual cookies in the cookie jar.  This is considered private
+    # API and behavior of this class can change at any time.
     class Cookie # :nodoc:
       include Rack::Utils
 
-      # :api: private
-      attr_reader :name, :value
+      # The name of the cookie, will be a string
+      attr_reader :name
+      
+      # The value of the cookie, will be a string or nil if there is no value.
+      attr_reader :value
+
+      # The raw string for the cookie, without options. Will generally be in
+      # name=value format is name and value are provided.
+      attr_reader :raw
 
-      # :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)
+        @raw, options = raw.split(/[;,] */n, 2)
 
-        @name, @value = parse_query(@name_value_raw, ';').to_a.first
+        @name, @value = parse_query(@raw, ';').to_a.first
         @options = parse_query(options, ';')
 
-        @options["domain"]  ||= (uri.host || default_host)
-        @options["path"]    ||= uri.path.sub(/\/[^\/]*\Z/, "")
+        if domain = @options['domain']
+          @exact_domain_match = false
+          domain[0] = '' if domain[0] == '.'
+        else
+          # If the domain attribute is not present in the cookie,
+          # the domain must match exactly.
+          @exact_domain_match = true
+          @options['domain'] = (uri.host || default_host)
+        end
+
+        # Set the path for the cookie to the directory containing
+        # the request if it isn't set.
+        @options['path'] ||= uri.path.sub(/\/[^\/]*\Z/, '')
       end
 
+      # Wether the given cookie can replace the current cookie in the cookie jar.
       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
+      # Whether the cookie has a value.
       def empty?
         @value.nil? || @value.empty?
       end
 
-      # :api: private
+      # The explicit or implicit domain for the cookie.
       def domain
-        @options["domain"]
+        @options['domain']
       end
 
+      # Whether the cookie has the secure flag, indicating it can only be sent over
+      # an encrypted connection.
       def secure?
-        @options.has_key?("secure")
+        @options.key?('secure')
       end
 
-      # :api: private
+      # Whether the cookie has the httponly flag, indicating it is not available via
+      # a javascript API.
+      def http_only?
+        @options.key?('HttpOnly') || @options.key?('httponly')
+      end
+
+      # The explicit or implicit path for the cookie.
       def path
-        @options["path"].strip || "/"
+        ([*@options['path']].first.split(',').first || '/').strip
       end
 
-      # :api: private
+      # A Time value for when the cookie expires, if the expires option is set.
       def expires
-        Time.parse(@options["expires"]) if @options["expires"]
+        Time.parse(@options['expires']) if @options['expires']
       end
 
-      # :api: private
+      # Whether the cookie is currently expired.
       def expired?
         expires && expires < Time.now
       end
 
-      # :api: private
+      # Whether the cookie is valid for the given URI.
       def valid?(uri)
         uri ||= default_uri
 
-        if uri.host.nil?
-          uri.host = @default_host
-        end
+        uri.host = @default_host if uri.host.nil?
 
         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)}")
+        !!((!secure? || (secure? && uri.scheme == 'https')) &&
+          uri.host =~ Regexp.new("#{'^' if @exact_domain_match}#{Regexp.escape(real_domain)}$", Regexp::IGNORECASE))
       end
 
-      # :api: private
+      # Cookies that do not match the URI will not be sent in requests to the URI.
       def matches?(uri)
-        ! expired? && valid?(uri)
+        !expired? && valid?(uri) && uri.path.start_with?(path)
       end
 
-      # :api: private
+      # Order cookies by name, path, and domain.
       def <=>(other)
-        # Orders the cookies from least specific to most
         [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
       end
 
-    protected
+      # A hash of cookie options, including the cookie value, but excluding the cookie name.
+      def to_h
+        @options.merge(
+          'value'    => @value,
+          'HttpOnly' => http_only?,
+          'secure'   => secure?
+        )
+      end
+      alias to_hash to_h
+
+      private
 
+      # The default URI to use for the cookie, including just the host.
       def default_uri
-        URI.parse("//" + @default_host + "/")
+        URI.parse('//' + @default_host + '/')
       end
-
     end
 
+    # Represents all cookies for a session, handling adding and
+    # removing cookies, and finding which cookies apply to a given
+    # request.  This is considered private API and behavior of this
+    # class can change at any time.
     class CookieJar # :nodoc:
+      DELIMITER = '; '.freeze
 
-      # :api: private
       def initialize(cookies = [], default_host = DEFAULT_HOST)
         @default_host = default_host
-        @cookies = cookies
-        @cookies.sort!
+        @cookies = cookies.sort!
+      end
+
+      # Ensure the copy uses a distinct cookies array.
+      def initialize_copy(other)
+        super
+        @cookies = @cookies.dup
       end
 
+      # Return the value for first cookie with the given name, or nil
+      # if no such cookie exists.
       def [](name)
-        cookies = hash_for(nil)
-        # TODO: Should be case insensitive
-        cookies[name] && cookies[name].value
+        name = name.to_s
+        @cookies.each do |cookie|
+          return cookie.value if cookie.name == name
+        end
+        nil
       end
 
+      # Set a cookie with the given name and value in the
+      # cookie jar.
       def []=(name, value)
         merge("#{name}=#{Rack::Utils.escape(value)}")
       end
 
+      # Return the first cookie with the given name, or nil if
+      # no such cookie exists.
+      def get_cookie(name)
+        @cookies.each do |cookie|
+          return cookie if cookie.name == name
+        end
+        nil
+      end
+
+      # Delete all cookies with the given name from the cookie jar.
       def delete(name)
         @cookies.reject! do |cookie|
           cookie.name == name
         end
+        nil
       end
 
+      # Add a string of raw cookie information to the cookie jar,
+      # if the cookie is valid for the given URI.
+      # Cookies should be separated with a newline.
       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? }
+          raw_cookies.reject!(&:empty?)
         end
 
         raw_cookies.each do |raw_cookie|
@@ -135,6 +194,7 @@ module Rack
         end
       end
 
+      # Add a Cookie to the cookie jar.
       def <<(new_cookie)
         @cookies.reject! do |existing_cookie|
           new_cookie.replaces?(existing_cookie)
@@ -144,39 +204,49 @@ module Rack
         @cookies.sort!
       end
 
-      # :api: private
+      # Return a raw cookie string for the cookie header to
+      # use for the given URI.
       def for(uri)
-        hash_for(uri).values.map { |c| c.raw }.join(';')
+        buf = String.new
+        delimiter = nil
+
+        each_cookie_for(uri) do |cookie|
+          if delimiter
+            buf << delimiter
+          else
+            delimiter = DELIMITER
+          end
+          buf << cookie.raw
+        end
+
+        buf
       end
 
+      # Return a hash cookie names and cookie values for cookies in the jar.
       def to_hash
         cookies = {}
 
-        hash_for(nil).each do |name, cookie|
-          cookies[name] = cookie.value
+        @cookies.each do |cookie|
+          cookies[cookie.name] = cookie.value
         end
 
-        return cookies
+        cookies
       end
 
-    protected
-
-      def hash_for(uri = nil)
-        cookies = {}
+      private
 
-        # 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.
+      # Yield each cookie that matches for the URI.
+      #
+      # 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.
+      def each_cookie_for(uri)
         @cookies.each do |cookie|
-          cookies[cookie.name] = cookie if !uri || cookie.matches?(uri)
+          yield cookie if !uri || cookie.matches?(uri)
         end
-
-        return cookies
       end
-
     end
-
   end
 end

data/lib/rack/test/methods.rb

@@ -1,12 +1,16 @@
-require "forwardable"
+# frozen_string_literal: true
+
+require 'forwardable'
 
 module Rack
   module Test
-
     # This module serves as the primary integration point for using Rack::Test
     # in a testing environment. It depends on an app method being defined in the
     # same context, and provides the Rack::Test API methods (see Rack::Test::Session
-    # for their documentation).
+    # for their documentation). It defines the following methods that are delegated
+    # to the current session: :request, :get, :post, :put, :patch, :delete, :options,
+    # :head, :custom_request, :follow_redirect!, :header, :env, :set_cookie,
+    # :clear_cookies, :authorize, :basic_authorize, :last_response, and :last_request.
     #
     # Example:
     #
@@ -14,23 +18,14 @@ module Rack
     #     include Rack::Test::Methods
     #
     #     def app
-    #       MyApp.new
+    #       MyApp
     #     end
     #   end
     module Methods
       extend Forwardable
 
-      def rack_mock_session(name = :default) # :nodoc:
-        return build_rack_mock_session unless name
-
-        @_rack_mock_sessions ||= {}
-        @_rack_mock_sessions[name] ||= build_rack_mock_session
-      end
-
-      def build_rack_mock_session # :nodoc:
-        Rack::MockSession.new(app)
-      end
-
+      # Return the existing session with the given name, or a new
+      # rack session.  Always use a new session if name is nil.
       def rack_test_session(name = :default) # :nodoc:
         return build_rack_test_session(name) unless name
 
@@ -38,25 +33,39 @@ module Rack
         @_rack_test_sessions[name] ||= build_rack_test_session(name)
       end
 
-      def build_rack_test_session(name) # :nodoc:
-        Rack::Test::Session.new(rack_mock_session(name))
-      end
+      # For backwards compatibility with older rack-test versions.
+      alias rack_mock_session rack_test_session # :nodoc:
 
-      def current_session # :nodoc:
-        rack_test_session(_current_session_names.last)
+      # Create a new Rack::Test::Session for #app.
+      def build_rack_test_session(_name) # :nodoc:
+        if respond_to?(:build_rack_mock_session, true)
+          # Backwards compatibility for capybara
+          build_rack_mock_session
+        else
+          if respond_to?(:default_host)
+            Session.new(app, default_host)
+          else
+            Session.new(app)
+          end
+        end
       end
 
-      def with_session(name) # :nodoc:
-        _current_session_names.push(name)
-        yield rack_test_session(name)
-        _current_session_names.pop
+      # Return the currently actively session.  This is the session to
+      # which the delegated methods are sent.
+      def current_session
+        @_rack_test_current_session ||= rack_test_session
       end
 
-      def _current_session_names # :nodoc:
-        @_current_session_names ||= [:default]
+      # Create a new session (or reuse an existing session with the given name),
+      # and make it the current session for the given block.
+      def with_session(name)
+        session = _rack_test_current_session
+        yield(@_rack_test_current_session = rack_test_session(name))
+      ensure
+        @_rack_test_current_session = session
       end
 
-      METHODS = [
+      def_delegators(:current_session,
         :request,
         :get,
         :post,
@@ -65,6 +74,7 @@ module Rack
         :delete,
         :options,
         :head,
+        :custom_request,
         :follow_redirect!,
         :header,
         :env,
@@ -72,12 +82,13 @@ module Rack
         :clear_cookies,
         :authorize,
         :basic_authorize,
-        :digest_authorize,
         :last_response,
-        :last_request
-      ]
+        :last_request,
+      )
 
-      def_delegators :current_session, *METHODS
+      # Private accessor to avoid uninitialized instance variable warning in Ruby 2.*
+      attr_accessor :_rack_test_current_session
+      private :_rack_test_current_session
     end
   end
 end

data/lib/rack/test/uploaded_file.rb

@@ -1,16 +1,17 @@
-require "tempfile"
-require "fileutils"
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tempfile'
+require 'stringio'
 
 module Rack
   module Test
-
     # Wraps a Tempfile with a content type. Including one or more UploadedFile's
     # in the params causes Rack::Test to build and issue a multipart request.
     #
     # Example:
     #   post "/photos", "file" => Rack::Test::UploadedFile.new("me.jpg", "image/jpeg")
     class UploadedFile
-
       # The filename, *not* including the path, of the "uploaded" file
       attr_reader :original_filename
 
@@ -20,34 +21,93 @@ module Rack
       # The content type of the "uploaded" file
       attr_accessor :content_type
 
-      def initialize(path, content_type = "text/plain", binary = false)
-        raise "#{path} file does not exist" unless ::File.exist?(path)
-
+      # Creates a new UploadedFile instance.
+      #
+      # Arguments:
+      # content :: is a path to a file, or an {IO} or {StringIO} object representing the content.
+      # content_type :: MIME type of the file
+      # binary :: Whether the file should be set to binmode (content treated as binary).
+      # original_filename :: The filename to use for the file. Required if content is StringIO, optional override if not
+      def initialize(content, content_type = 'text/plain', binary = false, original_filename: nil)
         @content_type = content_type
-        @original_filename = ::File.basename(path)
+        @original_filename = original_filename
 
-        @tempfile = Tempfile.new(@original_filename)
-        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
-        @tempfile.binmode if binary
+        case content
+        when StringIO
+          initialize_from_stringio(content)
+        else
+          initialize_from_file_path(content)
+        end
 
-        FileUtils.copy_file(path, @tempfile.path)
+        @tempfile.binmode if binary
       end
 
+      # The path to the tempfile. Will not work if the receiver's content is from a StringIO.
       def path
-        @tempfile.path
+        tempfile.path
+      end
+      alias local_path path
+
+      # Delegate all methods not handled to the tempfile.
+      def method_missing(method_name, *args, &block)
+        tempfile.public_send(method_name, *args, &block)
       end
 
-      alias_method :local_path, :path
+      # Append to given buffer in 64K chunks to avoid multiple large
+      # copies of file data in memory.  Rewind tempfile before and
+      # after to make sure all data in tempfile is appended to the
+      # buffer.
+      def append_to(buffer)
+        tempfile.rewind
+
+        buf = String.new
+        buffer << tempfile.readpartial(65_536, buf) until tempfile.eof?
 
-      def method_missing(method_name, *args, &block) #:nodoc:
-        @tempfile.__send__(method_name, *args, &block)
+        tempfile.rewind
+
+        nil
       end
 
-      def respond_to?(method_name, include_private = false) #:nodoc:
-        @tempfile.respond_to?(method_name, include_private) || super
+      def respond_to_missing?(method_name, include_private = false) #:nodoc:
+        tempfile.respond_to?(method_name, include_private) || super
       end
 
-    end
+      # A proc that can be used as a finalizer to close and unlink the tempfile.
+      def self.finalize(file)
+        proc { actually_finalize file }
+      end
 
+      # Close and unlink the given file, used as a finalizer for the tempfile,
+      # if the tempfile is backed by a file in the filesystem.
+      def self.actually_finalize(file)
+        file.close
+        file.unlink
+      end
+
+      private
+
+      # Use the StringIO as the tempfile.
+      def initialize_from_stringio(stringio)
+        raise(ArgumentError, 'Missing `original_filename` for StringIO object') unless @original_filename
+
+        @tempfile = stringio
+      end
+
+      # Create a tempfile and copy the content from the given path into the tempfile, optionally renaming if
+      # original_filename has been set.
+      def initialize_from_file_path(path)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+
+        @original_filename ||= ::File.basename(path)
+        extension = ::File.extname(@original_filename)
+
+        @tempfile = Tempfile.new([::File.basename(@original_filename, extension), extension])
+        @tempfile.set_encoding(Encoding::BINARY)
+
+        ObjectSpace.define_finalizer(self, self.class.finalize(@tempfile))
+
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+    end
   end
 end