rack-test 0.6.3 → 0.8.0

data/lib/rack/test/cookie_jar.rb

@@ -1,9 +1,8 @@
-require "uri"
-require "time"
+require 'uri'
+require 'time'
 
 module Rack
   module Test
-
     class Cookie # :nodoc:
       include Rack::Utils
 
@@ -21,8 +20,8 @@ module Rack
         @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/, "")
+        @options['domain']  ||= (uri.host || default_host)
+        @options['path']    ||= uri.path.sub(/\/[^\/]*\Z/, '')
       end
 
       def replaces?(other)
@@ -41,21 +40,25 @@ module Rack
 
       # :api: private
       def domain
-        @options["domain"]
+        @options['domain']
       end
 
       def secure?
-        @options.has_key?("secure")
+        @options.key?('secure')
+      end
+
+      def http_only?
+        @options.key?('HttpOnly')
       end
 
       # :api: private
       def path
-        @options["path"].strip || "/"
+        ([*@options['path']].first.split(',').first || '/').strip
       end
 
       # :api: private
       def expires
-        Time.parse(@options["expires"]) if @options["expires"]
+        Time.parse(@options['expires']) if @options['expires']
       end
 
       # :api: private
@@ -67,19 +70,17 @@ module Rack
       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("#{Regexp.escape(real_domain)}$", Regexp::IGNORECASE) &&
+          uri.path =~ Regexp.new("^#{Regexp.escape(path)}")
       end
 
       # :api: private
       def matches?(uri)
-        ! expired? && valid?(uri)
+        !expired? && valid?(uri)
       end
 
       # :api: private
@@ -88,16 +89,23 @@ module Rack
         [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
       end
 
-    protected
+      def to_h
+        @options.merge(
+          'value'    => @value,
+          'HttpOnly' => http_only?,
+          'secure'   => secure?
+        )
+      end
+      alias to_hash to_h
+
+      protected
 
       def default_uri
-        URI.parse("//" + @default_host + "/")
+        URI.parse('//' + @default_host + '/')
       end
-
     end
 
     class CookieJar # :nodoc:
-
       # :api: private
       def initialize(cookies = [], default_host = DEFAULT_HOST)
         @default_host = default_host
@@ -108,13 +116,17 @@ module Rack
       def [](name)
         cookies = hash_for(nil)
         # TODO: Should be case insensitive
-        cookies[name] && cookies[name].value
+        cookies[name.to_s] && cookies[name.to_s].value
       end
 
       def []=(name, value)
         merge("#{name}=#{Rack::Utils.escape(value)}")
       end
 
+      def get_cookie(name)
+        hash_for(nil).fetch(name, nil)
+      end
+
       def delete(name)
         @cookies.reject! do |cookie|
           cookie.name == name
@@ -126,7 +138,7 @@ module Rack
 
         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|
@@ -146,7 +158,7 @@ module Rack
 
       # :api: private
       def for(uri)
-        hash_for(uri).values.map { |c| c.raw }.join(';')
+        hash_for(uri).values.map(&:raw).join(';')
       end
 
       def to_hash
@@ -156,10 +168,10 @@ module Rack
           cookies[name] = cookie.value
         end
 
-        return cookies
+        cookies
       end
 
-    protected
+      protected
 
       def hash_for(uri = nil)
         cookies = {}
@@ -173,10 +185,8 @@ module Rack
           cookies[cookie.name] = cookie if !uri || cookie.matches?(uri)
         end
 
-        return cookies
+        cookies
       end
-
     end
-
   end
 end

data/lib/rack/test/methods.rb

@@ -1,8 +1,7 @@
-require "forwardable"
+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
@@ -56,26 +55,27 @@ module Rack
         @_current_session_names ||= [:default]
       end
 
-      METHODS = [
-        :request,
-        :get,
-        :post,
-        :put,
-        :patch,
-        :delete,
-        :options,
-        :head,
-        :follow_redirect!,
-        :header,
-        :env,
-        :set_cookie,
-        :clear_cookies,
-        :authorize,
-        :basic_authorize,
-        :digest_authorize,
-        :last_response,
-        :last_request
-      ]
+      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, *METHODS
     end

data/lib/rack/test/mock_digest_request.rb

@@ -1,14 +1,12 @@
 module Rack
   module Test
-
     class MockDigestRequest # :nodoc:
-
       def initialize(params)
         @params = params
       end
 
       def method_missing(sym)
-        if @params.has_key? k = sym.to_s
+        if @params.key? k = sym.to_s
           return @params[k]
         end
 
@@ -22,8 +20,6 @@ module Rack
       def response(password)
         Rack::Auth::Digest::MD5.new(nil).send :digest, self, password
       end
-
     end
-
   end
 end

data/lib/rack/test/uploaded_file.rb

@@ -1,16 +1,14 @@
-require "tempfile"
-require "fileutils"
+require 'tempfile'
+require 'fileutils'
 
 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 +18,58 @@ 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)
-
+      def initialize(content, content_type = 'text/plain', binary = false, original_filename: nil)
+        if content.respond_to?(:read)
+          initialize_from_io(content, original_filename)
+        else
+          initialize_from_file_path(content)
+        end
         @content_type = content_type
-        @original_filename = ::File.basename(path)
-
-        @tempfile = Tempfile.new(@original_filename)
-        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
         @tempfile.binmode if binary
-
-        FileUtils.copy_file(path, @tempfile.path)
       end
 
       def path
-        @tempfile.path
+        tempfile.path
       end
 
-      alias_method :local_path, :path
+      alias local_path path
 
       def method_missing(method_name, *args, &block) #:nodoc:
-        @tempfile.__send__(method_name, *args, &block)
+        tempfile.public_send(method_name, *args, &block)
       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
+      def self.finalize(file)
+        proc { actually_finalize file }
+      end
+
+      def self.actually_finalize(file)
+        file.close
+        file.unlink
+      end
 
+      private
+
+      def initialize_from_io(io, original_filename)
+        @tempfile = io
+        @original_filename = original_filename || raise(ArgumentError, 'Missing `original_filename` for IO')
+      end
+
+      def initialize_from_file_path(path)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+
+        @original_filename = ::File.basename(path)
+
+        @tempfile = Tempfile.new([@original_filename, ::File.extname(path)])
+        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+
+        ObjectSpace.define_finalizer(self, self.class.finalize(@tempfile))
+
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+    end
   end
 end

data/lib/rack/test/utils.rb

@@ -1,38 +1,36 @@
 module Rack
   module Test
-
     module Utils # :nodoc:
       include Rack::Utils
+      extend Rack::Utils
 
       def build_nested_query(value, prefix = nil)
         case value
         when Array
-          value.map do |v|
-            unless unescape(prefix) =~ /\[\]$/
-              prefix = "#{prefix}[]"
-            end
-            build_nested_query(v, "#{prefix}")
-          end.join("&")
+          if value.empty?
+            "#{prefix}[]="
+          else
+            value.map do |v|
+              prefix = "#{prefix}[]" unless unescape(prefix) =~ /\[\]$/
+              build_nested_query(v, prefix.to_s)
+            end.join('&')
+          end
         when Hash
           value.map do |k, v|
             build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-          end.join("&")
+          end.join('&')
         when NilClass
           prefix.to_s
         else
           "#{prefix}=#{escape(value)}"
         end
       end
-
       module_function :build_nested_query
 
-      def build_multipart(params, first = true)
+      def build_multipart(params, first = true, multipart = false)
         if first
-          unless params.is_a?(Hash)
-            raise ArgumentError, "value must be a Hash"
-          end
+          raise ArgumentError, 'value must be a Hash' unless params.is_a?(Hash)
 
-          multipart = false
           query = lambda { |value|
             case value
             when Array
@@ -47,7 +45,7 @@ module Rack
           return nil unless multipart
         end
 
-        flattened_params = Hash.new
+        flattened_params = {}
 
         params.each do |key, value|
           k = first ? key.to_s : "[#{key}]"
@@ -55,23 +53,21 @@ module Rack
           case value
           when Array
             value.map do |v|
-
-              if (v.is_a?(Hash))
+              if v.is_a?(Hash)
                 nested_params = {}
-                build_multipart(v, false).each { |subkey, subvalue|
+                build_multipart(v, false).each do |subkey, subvalue|
                   nested_params[subkey] = subvalue
-                }
+                end
                 flattened_params["#{k}[]"] ||= []
                 flattened_params["#{k}[]"] << nested_params
               else
                 flattened_params["#{k}[]"] = value
               end
-
             end
           when Hash
-            build_multipart(value, false).each { |subkey, subvalue|
+            build_multipart(value, false).each do |subkey, subvalue|
               flattened_params[k + subkey] = subvalue
-            }
+            end
           else
             flattened_params[k] = value
           end
@@ -83,27 +79,28 @@ module Rack
           flattened_params
         end
       end
-
       module_function :build_multipart
 
-    private
+      private
+
       def build_parts(parameters)
         get_parts(parameters).join + "--#{MULTIPART_BOUNDARY}--\r"
       end
+      module_function :build_parts
 
       def get_parts(parameters)
-        parameters.map { |name, value|
-          if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}
-            value.map { |hash|
+        parameters.map do |name, value|
+          if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? { |v| v.is_a?(Hash) }
+            value.map do |hash|
               new_value = {}
-              hash.each { |k, v| new_value[name+k] = v }
+              hash.each { |k, v| new_value[name + k] = v }
               get_parts(new_value).join
-            }.join
+            end.join
           else
             if value.respond_to?(:original_filename)
               build_file_part(name, value)
 
-            elsif value.is_a?(Array) and value.all? { |v| v.respond_to?(:original_filename) }
+            elsif value.is_a?(Array) && value.all? { |v| v.respond_to?(:original_filename) }
               value.map do |v|
                 build_file_part(name, v)
               end.join
@@ -113,15 +110,14 @@ module Rack
               Rack::Test.encoding_aware_strings? ? primitive_part.force_encoding('BINARY') : primitive_part
             end
           end
-        }
+        end
       end
+      module_function :get_parts
 
       def build_primitive_part(parameter_name, value)
-        unless value.is_a? Array
-          value = [value]
-        end
+        value = [value] unless value.is_a? Array
         value.map do |v|
-<<-EOF
+          <<-EOF
 --#{MULTIPART_BOUNDARY}\r
 Content-Disposition: form-data; name="#{parameter_name}"\r
 \r
@@ -129,22 +125,20 @@ Content-Disposition: form-data; name="#{parameter_name}"\r
 EOF
         end.join
       end
+      module_function :build_primitive_part
 
       def build_file_part(parameter_name, uploaded_file)
-        ::File.open(uploaded_file.path, "rb") do |physical_file|
-          physical_file.set_encoding(Encoding::BINARY) if physical_file.respond_to?(:set_encoding)
-<<-EOF
+        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: #{::File.stat(uploaded_file.path).size}\r
+Content-Length: #{uploaded_file.size}\r
 \r
-#{physical_file.read}\r
+#{uploaded_file.read}\r
 EOF
-        end
       end
-
+      module_function :build_file_part
     end
-
   end
 end