rack-test 1.1.0 → 2.1.0

data/lib/rack/test/methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Rack
@@ -5,7 +7,10 @@ module Rack
     # 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:
     #
@@ -13,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
 
@@ -37,47 +33,62 @@ 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 = %i[
-        request
-        get
-        post
-        put
-        patch
-        delete
-        options
-        head
-        custom_request
-        follow_redirect!
-        header
-        env
-        set_cookie
-        clear_cookies
-        authorize
-        basic_authorize
-        digest_authorize
-        last_response
-        last_request
-      ].freeze
+      def_delegators(: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,
+        :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,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'fileutils'
-require 'pathname'
 require 'tempfile'
+require 'stringio'
 
 module Rack
   module Test
@@ -21,40 +23,62 @@ module Rack
 
       # Creates a new UploadedFile instance.
       #
-      # @param content [IO, Pathname, String, StringIO] a path to a file, or an {IO} or {StringIO} object representing the
-      #   file.
-      # @param content_type [String]
-      # @param binary [Boolean] an optional flag that indicates whether the file should be open in binary mode or not.
-      # @param original_filename [String] an optional parameter that provides the original filename if `content` is a StringIO
-      #   object. Not used for other kind of `content` objects.
+      # 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)
-        if original_filename
-          initialize_from_stringio(content, original_filename)
+        @content_type = content_type
+        @original_filename = original_filename
+
+        case content
+        when StringIO
+          initialize_from_stringio(content)
         else
           initialize_from_file_path(content)
         end
-        @content_type = content_type
+
         @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
       end
-
       alias local_path path
 
-      def method_missing(method_name, *args, &block) #:nodoc:
+      # Delegate all methods not handled to the tempfile.
+      def method_missing(method_name, *args, &block)
         tempfile.public_send(method_name, *args, &block)
       end
 
+      # 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?
+
+        tempfile.rewind
+
+        nil
+      end
+
       def respond_to_missing?(method_name, include_private = false) #:nodoc:
         tempfile.respond_to?(method_name, include_private) || super
       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
@@ -62,19 +86,23 @@ module Rack
 
       private
 
-      def initialize_from_stringio(stringio, original_filename)
+      # Use the StringIO as the tempfile.
+      def initialize_from_stringio(stringio)
+        raise(ArgumentError, 'Missing `original_filename` for StringIO object') unless @original_filename
+
         @tempfile = stringio
-        @original_filename = original_filename || raise(ArgumentError, 'Missing `original_filename` for StringIO object')
       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)
+        @original_filename ||= ::File.basename(path)
         extension = ::File.extname(@original_filename)
 
         @tempfile = Tempfile.new([::File.basename(@original_filename, extension), extension])
-        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+        @tempfile.set_encoding(Encoding::BINARY)
 
         ObjectSpace.define_finalizer(self, self.class.finalize(@tempfile))
 

data/lib/rack/test/utils.rb

@@ -1,17 +1,21 @@
+# frozen_string_literal: true
+
 module Rack
   module Test
     module Utils # :nodoc:
       include Rack::Utils
-      extend Rack::Utils
+      extend self
 
+      # Build a query string for the given value and prefix. The value
+      # can be an array or hash of parameters.
       def build_nested_query(value, prefix = nil)
         case value
         when Array
           if value.empty?
             "#{prefix}[]="
           else
+            prefix += "[]" unless unescape(prefix).end_with?('[]')
             value.map do |v|
-              prefix = "#{prefix}[]" unless unescape(prefix) =~ /\[\]$/
               build_nested_query(v, prefix.to_s)
             end.join('&')
           end
@@ -25,12 +29,12 @@ module Rack
           "#{prefix}=#{escape(value)}"
         end
       end
-      module_function :build_nested_query
 
-      def build_multipart(params, first = true, multipart = false)
-        if first
-          raise ArgumentError, 'value must be a Hash' unless params.is_a?(Hash)
+      # Build a multipart body for the given params.
+      def build_multipart(params, _first = true, multipart = false)
+        raise ArgumentError, 'value must be a Hash' unless params.is_a?(Hash)
 
+        unless multipart
           query = lambda { |value|
             case value
             when Array
@@ -45,6 +49,17 @@ module Rack
           return nil unless multipart
         end
 
+        params = normalize_multipart_params(params, true)
+
+        buffer = String.new
+        build_parts(buffer, params)
+        buffer
+      end
+
+      private
+
+      # Return a flattened hash of parameter values based on the given params.
+      def normalize_multipart_params(params, first=false)
         flattened_params = {}
 
         params.each do |key, value|
@@ -55,17 +70,16 @@ module Rack
             value.map do |v|
               if v.is_a?(Hash)
                 nested_params = {}
-                build_multipart(v, false).each do |subkey, subvalue|
+                normalize_multipart_params(v).each do |subkey, subvalue|
                   nested_params[subkey] = subvalue
                 end
-                flattened_params["#{k}[]"] ||= []
-                flattened_params["#{k}[]"] << nested_params
+                (flattened_params["#{k}[]"] ||= []) << nested_params
               else
                 flattened_params["#{k}[]"] = value
               end
             end
           when Hash
-            build_multipart(value, false).each do |subkey, subvalue|
+            normalize_multipart_params(value).each do |subkey, subvalue|
               flattened_params[k + subkey] = subvalue
             end
           else
@@ -73,72 +87,70 @@ module Rack
           end
         end
 
-        if first
-          build_parts(flattened_params)
-        else
-          flattened_params
-        end
+        flattened_params
       end
-      module_function :build_multipart
-
-      private
 
-      def build_parts(parameters)
-        get_parts(parameters).join + "--#{MULTIPART_BOUNDARY}--\r"
+      # Build the multipart content for uploading.
+      def build_parts(buffer, parameters)
+        _build_parts(buffer, parameters)
+        buffer << END_BOUNDARY
       end
-      module_function :build_parts
 
-      def get_parts(parameters)
+      # Append each multipart parameter value to the buffer.
+      def _build_parts(buffer, parameters)
         parameters.map do |name, value|
           if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? { |v| v.is_a?(Hash) }
-            value.map do |hash|
+            value.each do |hash|
               new_value = {}
               hash.each { |k, v| new_value[name + k] = v }
-              get_parts(new_value).join
-            end.join
+              _build_parts(buffer, new_value)
+            end
           else
-            if value.respond_to?(:original_filename)
-              build_file_part(name, value)
-
-            elsif value.is_a?(Array) && value.all? { |v| v.respond_to?(:original_filename) }
-              value.map do |v|
-                build_file_part(name, v)
-              end.join
-
-            else
-              primitive_part = build_primitive_part(name, value)
-              Rack::Test.encoding_aware_strings? ? primitive_part.force_encoding('BINARY') : primitive_part
+            [value].flatten.map do |v|
+              if v.respond_to?(:original_filename)
+                build_file_part(buffer, name, v)
+              else
+                build_primitive_part(buffer, name, v)
+              end
             end
           end
         end
       end
-      module_function :get_parts
-
-      def build_primitive_part(parameter_name, value)
-        value = [value] unless value.is_a? Array
-        value.map do |v|
-          <<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{parameter_name}"\r
-\r
-#{v}\r
-EOF
-        end.join
+
+      # Append the multipart fragment for a parameter that isn't a file upload to the buffer.
+      def build_primitive_part(buffer, parameter_name, value)
+        buffer <<
+          START_BOUNDARY <<
+          "content-disposition: form-data; name=\"" <<
+          parameter_name.to_s.b <<
+          "\"\r\n\r\n" <<
+          value.to_s.b <<
+          "\r\n"
+        buffer
       end
-      module_function :build_primitive_part
-
-      def build_file_part(parameter_name, uploaded_file)
-        uploaded_file.set_encoding(Encoding::BINARY) if uploaded_file.respond_to?(:set_encoding)
-        <<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{parameter_name}"; filename="#{escape(uploaded_file.original_filename)}"\r
-Content-Type: #{uploaded_file.content_type}\r
-Content-Length: #{uploaded_file.size}\r
-\r
-#{uploaded_file.read}\r
-EOF
+
+      # Append the multipart fragment for a parameter that is a file upload to the buffer.
+      def build_file_part(buffer, parameter_name, uploaded_file)
+        buffer <<
+          START_BOUNDARY <<
+          "content-disposition: form-data; name=\"" <<
+          parameter_name.to_s.b <<
+          "\"; filename=\"" <<
+          escape_path(uploaded_file.original_filename).b <<
+          "\"\r\ncontent-type: " <<
+          uploaded_file.content_type.to_s.b <<
+          "\r\ncontent-length: " <<
+          uploaded_file.size.to_s.b <<
+          "\r\n\r\n"
+
+        # Handle old versions of Capybara::RackTest::Form::NilUploadedFile
+        if uploaded_file.respond_to?(:set_encoding)
+          uploaded_file.set_encoding(Encoding::BINARY)
+          uploaded_file.append_to(buffer)
+        end
+
+        buffer << "\r\n"
       end
-      module_function :build_file_part
     end
   end
 end

data/lib/rack/test/version.rb

@@ -1,5 +1,5 @@
 module Rack
   module Test
-    VERSION = '1.1.0'.freeze
+    VERSION = '2.1.0'.freeze
   end
 end