faraday 0.8.7 → 0.8.8

data/Gemfile

@@ -1,26 +1,20 @@
 source 'https://rubygems.org'
 
-group :development do
-  gem 'sinatra', '~> 1.3'
-end
+gem 'ffi-ncurses', '~> 0.3', :platforms => :jruby
+gem 'jruby-openssl', '~> 0.8.8', :platforms => :jruby
+gem 'rake'
 
 group :test do
-  gem 'em-http-request', '~> 1.0', :require => 'em-http'
-  gem 'em-synchrony', '~> 1.0', :require => ['em-synchrony', 'em-synchrony/em-http']
-  gem 'excon', '>= 0.16.1'
-  gem 'net-http-persistent', '~> 2.5', :require => false
-  gem 'leftright', '~> 0.9', :require => false
-  gem 'rack-test', '~> 0.6', :require => 'rack/test'
-end
-
-platforms :ruby do
-  gem 'patron', '~> 0.4', '> 0.4.1'
-  gem 'typhoeus', '~> 0.3.3'
-end
-
-platforms :jruby do
-  gem 'jruby-openssl', '~> 0.7'
-  gem 'ffi-ncurses', '~> 0.3'
+  gem 'em-http-request', '>= 1.1', :require => 'em-http'
+  gem 'em-synchrony', '>= 1.0', :require => ['em-synchrony', 'em-synchrony/em-http']
+  gem 'excon', '>= 0.25.3'
+  gem 'leftright', '>= 0.9', :require => false
+  gem 'net-http-persistent', '>= 2.5', :require => false
+  gem 'patron', '>= 0.4.2', :platforms => :ruby
+  gem 'rack-test', '>= 0.6', :require => 'rack/test'
+  gem 'simplecov'
+  gem 'sinatra', '~> 1.3'
+  gem 'typhoeus', '~> 0.3.3', :platforms => :ruby
 end
 
 gemspec

data/lib/faraday.rb

@@ -1,5 +1,5 @@
 module Faraday
-  VERSION = "0.8.7"
+  VERSION = "0.8.8"
 
   class << self
     attr_accessor :root_path, :lib_path

data/lib/faraday/adapter/em_http.rb

@@ -7,7 +7,6 @@ module Faraday
       module Options
         def connection_config(env)
           options = {}
-          configure_ssl(options, env)
           configure_proxy(options, env)
           configure_timeout(options, env)
           options
@@ -21,9 +20,6 @@ module Faraday
             # :file => 'path/to/file', # stream data off disk
           }
           configure_compression(options, env)
-          # configure_proxy_auth
-          # :proxy => {:authorization => [user, pass]}
-          # proxy[:username] && proxy[:password]
           options
         end
 
@@ -32,20 +28,12 @@ module Faraday
           body.respond_to?(:read) ? body.read : body
         end
 
-        def configure_ssl(options, env)
-          if ssl = env[:ssl]
-            # :ssl => {
-            #   :private_key_file => '/tmp/server.key',
-            #   :cert_chain_file => '/tmp/server.crt',
-            #   :verify_peer => false
-          end
-        end
-
         def configure_proxy(options, env)
           if proxy = request_options(env)[:proxy]
             options[:proxy] = {
               :host => proxy[:uri].host,
-              :port => proxy[:uri].port
+              :port => proxy[:uri].port,
+              :authorization => [proxy[:user], proxy[:password]]
             }
           end
         end
@@ -114,6 +102,12 @@ module Faraday
               }
           end
         end
+      rescue EventMachine::Connectify::CONNECTError => err
+        if err.message.include?("Proxy Authentication Required")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
       end
 
       # TODO: reuse the connection to support pipelining
@@ -140,6 +134,8 @@ module Faraday
         elsif msg == Errno::ECONNREFUSED
           errklass = Faraday::Error::ConnectionFailed
           msg = "connection refused"
+        elsif msg == "connection closed by server"
+          errklass = Faraday::Error::ConnectionFailed
         end
         raise errklass, msg
       end

data/lib/faraday/adapter/em_synchrony.rb

@@ -52,6 +52,8 @@ module Faraday
             client = block.call
           end
 
+          raise client.error if client.error
+
           save_response(env, client.response_header.status, client.response) do |resp_headers|
             client.response_header.each do |name, value|
               resp_headers[name.to_sym] = value
@@ -62,6 +64,12 @@ module Faraday
         @app.call env
       rescue Errno::ECONNREFUSED
         raise Error::ConnectionFailed, $!
+      rescue EventMachine::Connectify::CONNECTError => err
+        if err.message.include?("Proxy Authentication Required")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
       end
     end
   end

data/lib/faraday/adapter/excon.rb

@@ -28,6 +28,16 @@ module Faraday
             opts[:connect_timeout]   = req[:open_timeout]
             opts[:write_timeout]     = req[:open_timeout]
           end
+
+          if req[:proxy]
+            opts[:proxy] = {
+              :host     => req[:proxy][:uri].host,
+              :port     => req[:proxy][:uri].port,
+              :scheme   => req[:proxy][:uri].scheme,
+              :user     => req[:proxy][:user],
+              :password => req[:proxy][:password]
+            }
+          end
         end
 
         conn = ::Excon.new(env[:url].to_s, opts)

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,4 +1,6 @@
-require 'faraday/adapter/net_http'
+# Rely on autoloading instead of explicit require; helps avoid the "already
+# initialized constant" warning on Ruby 1.8.7 when NetHttp is refereced below.
+# require 'faraday/adapter/net_http'
 
 module Faraday
   class Adapter
@@ -6,18 +8,26 @@ module Faraday
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
-      # TODO: investigate is it safe to create a new Persistent instance for
-      # every request, or does it defy the purpose of persistent connections
       def net_http_connection(env)
-        Net::HTTP::Persistent.new 'Faraday',
-          env[:request][:proxy] ? env[:request][:proxy][:uri] : nil
+        if proxy = env[:request][:proxy]
+          proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
+          proxy_uri.user = proxy_uri.password = nil
+          # awful patch for net-http-persistent 2.8 not unescaping user/password
+          (class << proxy_uri; self; end).class_eval do
+            define_method(:user) { proxy[:user] }
+            define_method(:password) { proxy[:password] }
+          end if proxy[:user]
+        end
+        Net::HTTP::Persistent.new 'Faraday', proxy_uri
       end
 
       def perform_request(http, env)
         http.request env[:url], create_request(env)
       rescue Net::HTTP::Persistent::Error => error
-        if error.message.include? 'Timeout::Error'
+        if error.message.include? 'Timeout'
           raise Faraday::Error::TimeoutError, error
+        elsif error.message.include? 'connection refused'
+          raise Faraday::Error::ConnectionFailed, error
         else
           raise
         end

data/lib/faraday/adapter/patron.rb

@@ -5,7 +5,7 @@ module Faraday
 
       def initialize(app, &block)
         super(app)
-        @block = block if block_given?
+        @block = block
       end
 
       def call(env)
@@ -19,19 +19,19 @@ module Faraday
         if req = env[:request]
           session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
           session.connect_timeout = req[:open_timeout]              if req[:open_timeout]
-                    
+
           if proxy = req[:proxy]
-            session.proxy = proxy[:uri].to_s
-            if proxy[:user] && proxy[:password]
-              prepend_proxy_auth_string(proxy, session)
-            end
+            proxy_uri = proxy[:uri].dup
+            proxy_uri.user = proxy[:user] && Utils.escape(proxy[:user]).gsub('+', '%20')
+            proxy_uri.password = proxy[:password] && Utils.escape(proxy[:password]).gsub('+', '%20')
+            session.proxy = proxy_uri.to_s
           end
         end
 
         response = begin
           data = env[:body] ? env[:body].to_s : nil
           session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
-        rescue Errno::ECONNREFUSED
+        rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
           raise Error::ConnectionFailed, $!
         end
 
@@ -40,6 +40,12 @@ module Faraday
         @app.call env
       rescue ::Patron::TimeoutError => err
         raise Faraday::Error::TimeoutError, err
+      rescue ::Patron::Error => err
+        if err.message.include?("code 407")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
       end
 
       if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
@@ -58,9 +64,5 @@ module Faraday
         session
       end
     end
-    
-    def prepend_proxy_auth_string(proxy, session)
-      session.proxy.insert(7, "#{proxy[:user]}:#{proxy[:password]}@")
-    end
   end
 end

data/lib/faraday/adapter/typhoeus.rb

@@ -31,8 +31,13 @@ module Faraday
       end
 
       def request(env)
+        method = env[:method]
+        # For some reason, prevents Typhoeus from using "100-continue".
+        # We want this because Webrick 1.3.1 can't seem to handle it w/ PUT.
+        method = method.to_s.upcase if method == :put
+
         req = ::Typhoeus::Request.new env[:url].to_s,
-          :method  => env[:method],
+          :method  => method,
           :body    => env[:body],
           :headers => env[:request_headers],
           :disable_ssl_peer_verification => (env[:ssl] && !env[:ssl].fetch(:verify, true))
@@ -50,6 +55,15 @@ module Faraday
             end
           end
 
+          case resp.curl_return_code
+          when 0
+            # everything OK
+          when 7
+            raise Error::ConnectionFailed, resp.curl_error_message
+          else
+            raise Error::ClientError, resp.curl_error_message
+          end
+
           save_response(env, resp.code, resp.body) do |response_headers|
             response_headers.parse resp.headers
           end
@@ -76,8 +90,8 @@ module Faraday
 
         req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
 
-        if proxy[:username] && proxy[:password]
-          req.proxy_username = proxy[:username]
+        if proxy[:user] && proxy[:password]
+          req.proxy_username = proxy[:user]
           req.proxy_password = proxy[:password]
         end
       end

data/lib/faraday/connection.rb

@@ -54,7 +54,13 @@ module Faraday
       @headers.update options[:headers] if options[:headers]
 
       @proxy = nil
-      proxy(options.fetch(:proxy) { ENV['http_proxy'] })
+      proxy(options.fetch(:proxy) {
+        uri = ENV['http_proxy']
+        if uri && !uri.empty?
+          uri = 'http://' + uri if uri !~ /^http/i
+          uri
+        end
+      })
 
       yield self if block_given?
 

data/lib/faraday/request/multipart.rb

@@ -7,7 +7,7 @@ module Faraday
       match_content_type(env) do |params|
         env[:request] ||= {}
         env[:request][:boundary] ||= DEFAULT_BOUNDARY
-        env[:request_headers][CONTENT_TYPE] += ";boundary=#{env[:request][:boundary]}"
+        env[:request_headers][CONTENT_TYPE] += "; boundary=#{env[:request][:boundary]}"
         env[:body] = create_multipart(env, params)
       end
       @app.call env

data/lib/faraday/response/raise_error.rb

@@ -4,6 +4,9 @@ module Faraday
       case env[:status]
       when 404
         raise Faraday::Error::ResourceNotFound, response_values(env)
+      when 407
+        # mimic the behavior that we get with proxy requests with HTTPS
+        raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
       when 400...600
         raise Faraday::Error::ClientError, response_values(env)
       end

data/lib/faraday/utils.rb

@@ -173,8 +173,8 @@ module Faraday
     ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
 
     def escape(s)
-      s.to_s.gsub(ESCAPE_RE) {
-        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
+      s.to_s.gsub(ESCAPE_RE) {|match|
+        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
       }.tr(' ', '+')
     end
 

data/script/generate_certs

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# Usage: generate_certs
+# Generate test certs for testing Faraday with SSL
+
+require 'openssl'
+require 'fileutils'
+
+$shell = ARGV.include? '-s'
+
+# Adapted from WEBrick::Utils. Skips cert extensions so it
+# can be used as a CA bundle
+def create_self_signed_cert(bits, cn, comment)
+  rsa = OpenSSL::PKey::RSA.new(bits)
+  cert = OpenSSL::X509::Certificate.new
+  cert.version = 2
+  cert.serial = 1
+  name = OpenSSL::X509::Name.new(cn)
+  cert.subject = name
+  cert.issuer = name
+  cert.not_before = Time.now
+  cert.not_after = Time.now + (365*24*60*60)
+  cert.public_key = rsa.public_key
+  cert.sign(rsa, OpenSSL::Digest::SHA1.new)
+  return [cert, rsa]
+end
+
+def write(file, contents, env_var)
+  FileUtils.mkdir_p(File.dirname(file))
+  File.open(file, 'w') {|f| f.puts(contents) }
+  puts %(export #{env_var}="#{file}") if $shell
+end
+
+
+# One cert / CA for ease of testing when ignoring verification
+cert, key = create_self_signed_cert(1024, [['CN', 'localhost']], 'Faraday Test CA')
+write 'tmp/faraday-cert.key', key,  'SSL_KEY'
+write 'tmp/faraday-cert.crt', cert, 'SSL_FILE'
+
+# And a second CA to prove that verification can fail
+cert, key = create_self_signed_cert(1024, [['CN', 'real-ca.com']], 'A different CA')
+write 'tmp/faraday-different-ca-cert.key', key,  'SSL_KEY_ALT'
+write 'tmp/faraday-different-ca-cert.crt', cert, 'SSL_FILE_ALT'

data/script/proxy-server

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# Usage: script/proxy-server [-p PORT] [-u USER:PASSWORD]
+require 'webrick'
+require 'webrick/httpproxy'
+
+port = 4001
+
+if found = ARGV.index('-p')
+  port = ARGV[found + 1].to_i
+end
+if found = ARGV.index('-u')
+  username, password = ARGV[found + 1].split(':', 2)
+end
+
+match_credentials = lambda { |credentials|
+  got_username, got_password = credentials.to_s.unpack("m*")[0].split(":", 2)
+  got_username == username && got_password == password
+}
+
+log_io = $stdout
+log_io.sync = true
+
+webrick_opts = {
+  :Port => port, :Logger => WEBrick::Log::new(log_io),
+  :AccessLog => [[log_io, "[%{X-Faraday-Adapter}i] %m  %U  ->  %s %b"]],
+  :ProxyAuthProc => lambda { |req, res|
+    if username
+      type, credentials = req.header['proxy-authorization'].first.to_s.split(/\s+/, 2)
+      unless "Basic" == type && match_credentials.call(credentials)
+        raise WEBrick::HTTPStatus::ProxyAuthenticationRequired
+      end
+    end
+  }
+}
+
+proxy = WEBrick::HTTPProxyServer.new(webrick_opts)
+
+trap(:TERM) { proxy.shutdown }
+trap(:INT) { proxy.shutdown }
+
+proxy.start

data/script/server

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+old_verbose, $VERBOSE = $VERBOSE, nil
+begin
+  require File.expand_path('../../test/live_server', __FILE__)
+ensure
+  $VERBOSE = old_verbose
+end
+require 'webrick'
+
+port = 4000
+if found = ARGV.index('-p')
+  port = ARGV[found + 1].to_i
+end
+
+log_io = $stdout
+log_io.sync = true
+
+webrick_opts = {
+  :Port => port, :Logger => WEBrick::Log::new(log_io),
+  :AccessLog => [[log_io, "[%{X-Faraday-Adapter}i] %m  %U  ->  %s %b"]]
+}
+
+if ENV['SSL_KEY']
+  require 'openssl'
+  require 'webrick/https'
+  webrick_opts.update \
+    :SSLEnable       => true,
+    :SSLPrivateKey   => OpenSSL::PKey::RSA.new(File.read(ENV['SSL_KEY'])),
+    :SSLCertificate  => OpenSSL::X509::Certificate.new(File.read(ENV['SSL_FILE'])),
+    :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE
+end
+
+Rack::Handler::WEBrick.run(Faraday::LiveServer, webrick_opts) do |server|
+  trap(:INT)  { server.stop }
+  trap(:TERM) { server.stop }
+end

data/script/test

@@ -1,131 +1,170 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env bash
+# Usage: script/test [file] [adapter]... -- [test/unit options]
 # Runs the test suite against a local server spawned automatically in a
 # thread. After tests are done, the server is shut down.
 #
 # If filename arguments are given, only those files are run. If arguments given
 # are not filenames, they are taken as words that filter the list of files to run.
 #
-# Examples
+# Examples:
 #
 #   $ script/test
 #   $ script/test test/env_test.rb
 #   $ script/test excon typhoeus
+#
+#   # Run only tests matching /ssl/ for the net_http adapter, with SSL enabled.
 #   $ SSL=yes script/test net_http -- -n /ssl/
+#
+#   # Run against multiple rbenv versions
+#   $ RBENV_VERSIONS="1.9.3-p194 ree-1.8.7-2012.02" script/test
+set -e
+
+if [[ "$RUBYOPT" != *"bundler/setup"* ]]; then
+  export RUBYOPT="-rbundler/setup $RUBYOPT"
+fi
+
+port=3999
+proxy_port=3998
+scheme=http
+
+if [ "$SSL" = "yes" ]; then
+  scheme=https
+  if [ -z "$SSL_KEY" ] || [ -z "$SSL_FILE" ]; then
+    eval "$(script/generate_certs -s)"
+  fi
+fi
+
+find_test_files() {
+  find "$1" -name '*_test.rb'
+}
 
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup
-rescue Bundler::GemNotFound
-  $stderr.print "Error: "
-  $stderr.puts $!.message
-  warn "Run `bundle install` to install missing gems."
-  exit 1
-end
-
-$VERBOSE = true
-
-host      = 'localhost'
-logfile   = 'log/test.log'
-test_glob = 'test/**/*_test.rb'
-
-if ssl_mode = ENV['SSL'] == 'yes'
-  unless ENV['SSL_KEY'] and ENV['SSL_FILE']
-    key_file  = ENV['SSL_KEY']  = 'tmp/faraday-cert.key'
-    cert_file = ENV['SSL_FILE'] = 'tmp/faraday-cert.crt'
-    system 'rake', key_file, cert_file
-    abort unless $?.success?
-  end
-end
-
-require 'fileutils'
-FileUtils.mkdir_p 'log'
-
-# find available port
-require 'socket'
-port = begin
-  server = TCPServer.new(host, 0)
-  server.addr[1]
-ensure
-  server.close if server
-end
-
-server = nil
-
-Thread.abort_on_exception = true
-
-# start test server in a separate thread
-thread = Thread.new do
-  old_verbose, $VERBOSE = $VERBOSE, nil
-  begin
-    require File.expand_path('../../test/live_server', __FILE__)
-  ensure
-    $VERBOSE = old_verbose
-  end
-  require 'webrick'
-  log_io = File.open logfile, 'w'
-  log_io.sync = true
-  webrick_opts = {
-    :Port => port, :Logger => WEBrick::Log::new(log_io),
-    :AccessLog => [[log_io, "[%{X-Faraday-Adapter}i] %m  %U  ->  %s %b"]]
-  }
-  if ssl_mode
-    require 'webrick/https'
-    webrick_opts.update \
-      :SSLEnable       => true,
-      :SSLPrivateKey   => OpenSSL::PKey::RSA.new(File.read(key_file)),
-      :SSLCertificate  => OpenSSL::X509::Certificate.new(File.read(cert_file)),
-      :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE
-  end
-  Rack::Handler::WEBrick.run(Faraday::LiveServer, webrick_opts) {|serv| server = serv }
-end
-
-# find files to test
-test_files = Dir[test_glob]
-if ARGV.any?
-  all_files, test_files = test_files, []
-  args, extra_args = ARGV, []
-  if idx = args.index('--')
-     extra_args = args[(idx+1)..-1]
-     args = args[0, idx]
-  end
-  for arg in args
-    re = /(\b|_)#{arg}(\b|_)/
-    test_files.concat all_files.select { |f| f =~ re }
-  end
-  test_files.concat extra_args
-end
-
-require 'net/https'
-conn = Net::HTTP.new host, port
-conn.open_timeout = conn.read_timeout = 0.1
-conn.use_ssl      = ssl_mode
-conn.verify_mode  = OpenSSL::SSL::VERIFY_NONE
-
-# test if test server is accepting requests
-responsive = lambda { |path|
-  begin
-    res = conn.start { conn.get(path) }
-    res.is_a?(Net::HTTPSuccess)
-  rescue Errno::ECONNREFUSED, Errno::EBADF, Timeout::Error, Net::HTTPBadResponse
-    false
-  end
+filter_matching() {
+  pattern="$1"
+  shift
+  for line in "$@"; do
+    [[ $line == *"$pattern"* ]] && echo "$line"
+  done
+}
+
+start_server() {
+  mkdir -p log
+  script/server -p $port >log/test.log 2>&1 &
+  echo $!
 }
 
-server_pings = 0
-begin
-  # block until test server is ready
-  thread.join 0.05
-  server_pings += 1
-  abort "test server didn't manage to start" if server_pings >= 50
-end until responsive.call('/echo')
+start_proxy() {
+  mkdir -p log
+  script/proxy-server -p $proxy_port -u "faraday@test.local:there is cake" >log/proxy.log 2>&1 &
+  echo $!
+}
 
-ENV['LIVE'] = "http#{ssl_mode ? 's' : ''}://#{host}:#{port}"
-ok = system 'ruby', '-Ilib:test',
-  '-e', 'load(ARGV.shift) while ARGV.first =~ /^[^-]/',
-  *test_files
+server_started() {
+  lsof -i :${1?} >/dev/null
+}
+
+timestamp() {
+  date +%s
+}
 
-server.respond_to?(:stop!) ? server.stop! : server.stop
-thread.join
+wait_for_server() {
+  timeout=$(( `timestamp` + $1 ))
+  while true; do
+    if server_started "$2"; then
+      break
+    elif [ `timestamp` -gt "$timeout" ]; then
+      echo "timed out after $1 seconds" >&2
+      return 1
+    fi
+  done
+}
+
+filtered=
+IFS=$'\n' test_files=($(find_test_files "test"))
+declare -a explicit_files
+
+# Process filter arguments:
+# - test filenames as taken as-is
+# - other words are taken as pattern to match the list of known files against
+# - arguments after "--" are forwarded to the ruby process
+while [ $# -gt 0 ]; do
+  arg="$1"
+  shift
+  if [ "$arg" = "--" ]; then
+    break
+  elif [ -f "$arg" ]; then
+    filtered=true
+    explicit_files[${#explicit_files[@]}+1]="$arg"
+  else
+    filtered=true
+    IFS=$'\n' explicit_files=(
+      ${explicit_files[@]}
+      $(filter_matching "$arg" "${test_files[@]}" || true)
+    )
+  fi
+done
+
+# If there were filter args, replace test files list with the results
+if [ -n "$filtered" ]; then
+  if [ ${#explicit_files[@]} -eq 0 ]; then
+    echo "Error: no test files match" >&2
+    exit 1
+  else
+    test_files=(${explicit_files[@]})
+    echo running "${test_files[@]}"
+  fi
+fi
+
+# If there are any adapter tests, spin up the HTTP server
+if [ -n "$(filter_matching "adapters" "${test_files[@]}")" ]; then
+  if server_started $port; then
+    echo "aborted: another instance of server running on $port" >&2
+    exit 1
+  fi
+  server_pid=$(start_server)
+  proxy_pid=$(start_proxy)
+  wait_for_server 15 $port || {
+    cat log/test.log
+    exit 1
+  }
+  wait_for_server 5 $proxy_port
+  cleanup() {
+    if [ $? -ne 0 ] && [ -n "$TRAVIS" ]; then
+      cat log/test.log
+    fi
+    kill "$server_pid"
+    kill "$proxy_pid"
+  }
+  trap cleanup INT EXIT
+  export LIVE="${scheme}://localhost:${port}"
+  export LIVE_PROXY="http://faraday%40test.local:there%20is%20cake@localhost:${proxy_port}"
+fi
+
+warnings="${TMPDIR:-/tmp}/faraday-warnings.$$"
+
+run_test_files() {
+  # Save warnings on stderr to a separate file
+  RUBYOPT="$RUBYOPT -w" ruby -e 'while f=ARGV.shift and f!="--"; load f; end' "${test_files[@]}" -- "$@" \
+    2> >(tee >(grep 'warning:' >"$warnings") | grep -v 'warning:')
+}
+
+check_warnings() {
+  # Display Ruby warnings from this project's source files. Abort if any were found.
+  num="$(grep -F "$PWD" "$warnings" | grep -v "${PWD}/bundle" | sort | uniq -c | sort -rn | tee /dev/stderr | wc -l)"
+  rm -f "$warnings"
+  if [ "$num" -gt 0 ]; then
+    echo "FAILED: this test suite doesn't tolerate Ruby syntax warnings!" >&2
+    exit 1
+  fi
+}
 
-exit 1 unless ok
+if [ -n "$RBENV_VERSIONS" ]; then
+  IFS=' ' versions=($RBENV_VERSIONS)
+  for version in "${versions[@]}"; do
+    echo "[${version}]"
+    RBENV_VERSION="$version" run_test_files "$@"
+  done
+else
+  run_test_files "$@"
+fi
+
+check_warnings

data/test/adapters/excon_test.rb

@@ -8,6 +8,10 @@ module Adapters
     Integration.apply(self, :NonParallel) do
       # https://github.com/geemus/excon/issues/126 ?
       undef :test_timeout if ssl_mode?
+
+      # Excon lets OpenSSL::SSL::SSLError be raised without any way to
+      # distinguish whether it happened because of a 407 proxy response
+      undef :test_proxy_auth_fail if ssl_mode?
     end
   end
 end

data/test/adapters/integration.rb

@@ -57,7 +57,7 @@ module Adapters
     module Compression
       def test_GET_handles_compression
         res = get('echo_header', :name => 'accept-encoding')
-        assert_match /gzip;.+\bdeflate\b/, res.body
+        assert_match(/gzip;.+\bdeflate\b/, res.body)
       end
     end
 
@@ -117,7 +117,7 @@ module Adapters
         resp = post('file') do |req|
           req.body = {'uploaded_file' => Faraday::UploadIO.new(__FILE__, 'text/x-ruby')}
         end
-        assert_equal "file integration.rb text/x-ruby", resp.body
+        assert_equal "file integration.rb text/x-ruby #{File.size(__FILE__)}", resp.body
       end
 
       def test_PUT_send_url_encoded_params
@@ -166,6 +166,40 @@ module Adapters
         end
       end
 
+      def test_connection_error
+        assert_raise Faraday::Error::ConnectionFailed do
+          get 'http://localhost:4'
+        end
+      end
+
+      def test_proxy
+        proxy_uri = URI(ENV['LIVE_PROXY'])
+        conn = create_connection(:proxy => proxy_uri)
+
+        res = conn.get '/echo'
+        assert_equal 'get', res.body
+
+        unless self.class.ssl_mode?
+          # proxy can't append "Via" header for HTTPS responses
+          assert_match(/:#{proxy_uri.port}$/, res['via'])
+        end
+      end
+
+      def test_proxy_auth_fail
+        proxy_uri = URI(ENV['LIVE_PROXY'])
+        proxy_uri.password = 'WRONG'
+        conn = create_connection(:proxy => proxy_uri)
+
+        err = assert_raise Faraday::Error::ConnectionFailed do
+          conn.get '/echo'
+        end
+
+        unless self.class.ssl_mode? && self.class.jruby?
+          # JRuby raises "End of file reached" which cannot be distinguished from a 407
+          assert_equal %{407 "Proxy Authentication Required "}, err.message
+        end
+      end
+
       def adapter
         raise NotImplementedError.new("Need to override #adapter")
       end

data/test/adapters/net_http_persistent_test.rb

@@ -5,10 +5,7 @@ module Adapters
 
     def adapter() :net_http_persistent end
 
-    Integration.apply(self, :NonParallel) do
-      # https://github.com/drbrain/net-http-persistent/issues/33
-      undef :test_timeout
-    end
+    Integration.apply(self, :NonParallel)
 
   end
 end

data/test/adapters/rack_test.rb

@@ -22,5 +22,10 @@ module Adapters
       rescue Faraday::Error::ClientError
       end
     end
+
+    # test not applicable
+    undef test_connection_error
+    undef test_proxy
+    undef test_proxy_auth_fail
   end
 end

data/test/adapters/typhoeus_test.rb

@@ -8,6 +8,13 @@ module Adapters
     Integration.apply(self, :Parallel) do
       # https://github.com/dbalatero/typhoeus/issues/75
       undef :test_GET_with_body
+
+      # Not a Typhoeus bug, but WEBrick inability to handle "100-continue"
+      # which libcurl seems to generate for this particular request:
+      undef :test_POST_sends_files
+
+      # inconsistent outcomes ranging from successful response to connection error
+      undef :test_proxy_auth_fail if ssl_mode?
     end unless jruby?
 
   end

data/test/authentication_middleware_test.rb

@@ -37,9 +37,9 @@ class AuthenticationMiddlewareTest < Faraday::TestCase
     response = conn { |b|
       b.request :token_auth, 'baz', :foo => 42
     }.get('/auth-echo')
-    assert_match /^Token /, response.body
-    assert_match /token="baz"/, response.body
-    assert_match /foo="42"/, response.body
+    assert_match(/^Token /, response.body)
+    assert_match(/token="baz"/, response.body)
+    assert_match(/foo="42"/, response.body)
   end
 
   def test_token_middleware_does_not_interfere_with_existing_authorization
@@ -52,14 +52,14 @@ class AuthenticationMiddlewareTest < Faraday::TestCase
     response = conn { |b|
       b.request :authorization, 'custom', 'abc def'
     }.get('/auth-echo')
-    assert_match /^custom abc def$/, response.body
+    assert_match(/^custom abc def$/, response.body)
   end
 
   def test_authorization_middleware_with_hash
     response = conn { |b|
       b.request :authorization, 'baz', :foo => 42
     }.get('/auth-echo')
-    assert_match /^baz /, response.body
-    assert_match /foo="42"/, response.body
+    assert_match(/^baz /, response.body)
+    assert_match(/foo="42"/, response.body)
   end
 end

data/test/connection_test.rb

@@ -93,9 +93,9 @@ class TestConnection < Faraday::TestCase
 
     conn.token_auth 'abcdef', :nonce => 'abc'
     assert auth = conn.headers['Authorization']
-    assert_match /^Token /, auth
-    assert_match /token="abcdef"/, auth
-    assert_match /nonce="abc"/, auth
+    assert_match(/^Token /, auth)
+    assert_match(/token="abcdef"/, auth)
+    assert_match(/nonce="abc"/, auth)
   end
 
   def test_build_url_uses_connection_host_as_default_uri_host
@@ -263,6 +263,35 @@ class TestConnection < Faraday::TestCase
     end
   end
 
+  def test_proxy_accepts_env_without_scheme
+    with_env 'http_proxy', "localhost:8888" do
+      uri = Faraday::Connection.new.proxy[:uri]
+      assert_equal 'localhost', uri.host
+      assert_equal 8888, uri.port
+    end
+  end
+
+  def test_no_proxy_from_env
+    with_env 'http_proxy', nil do
+      conn = Faraday::Connection.new
+      assert_equal nil, conn.proxy
+    end
+  end
+
+  def test_no_proxy_from_blank_env
+    with_env 'http_proxy', '' do
+      conn = Faraday::Connection.new
+      assert_equal nil, conn.proxy
+    end
+  end
+
+  def test_proxy_doesnt_accept_uppercase_env
+    with_env 'HTTP_PROXY', "http://localhost:8888/" do
+      conn = Faraday::Connection.new
+      assert_nil conn.proxy
+    end
+  end
+
   def test_proxy_requires_uri
     conn = Faraday::Connection.new
     assert_raises ArgumentError do

data/test/helper.rb

@@ -3,6 +3,7 @@ unless ENV['CI']
     require 'simplecov'
     SimpleCov.start do
       add_filter 'test'
+      add_filter '/bundle/'
     end
   rescue LoadError
   end
@@ -20,14 +21,6 @@ end
 
 require File.expand_path('../../lib/faraday', __FILE__)
 
-begin
-  require 'ruby-debug'
-rescue LoadError
-  # ignore
-else
-  Debugger.start
-end
-
 require 'stringio'
 require 'uri'
 

data/test/live_server.rb

@@ -25,9 +25,11 @@ class LiveServer < Sinatra::Base
 
   post '/file' do
     if params[:uploaded_file].respond_to? :each_key
-      "file %s %s" % [
+      "file %s %s %d" % [
         params[:uploaded_file][:filename],
-        params[:uploaded_file][:type]]
+        params[:uploaded_file][:type],
+        params[:uploaded_file][:tempfile].size
+      ]
     else
       status 400
     end

data/test/multibyte.txt

@@ -0,0 +1 @@
+ファイル

data/test/request_middleware_test.rb

@@ -67,7 +67,7 @@ class RequestMiddlewareTest < Faraday::TestCase
       response = @conn.post('/echo', {:str => "eé cç aã aâ"})
       assert_equal "str=e%C3%A9+c%C3%A7+a%C3%A3+a%C3%A2", response.body
     }
-    assert err.empty?
+    assert err.empty?, "stderr did include: #{err}"
   end
 
   def test_url_encoded_unicode_with_kcode_set
@@ -76,7 +76,7 @@ class RequestMiddlewareTest < Faraday::TestCase
         response = @conn.post('/echo', {:str => "eé cç aã aâ"})
         assert_equal "str=e%C3%A9+c%C3%A7+a%C3%A3+a%C3%A2", response.body
       }
-      assert err.empty?
+      assert err.empty?, "stderr did include: #{err}"
     end
   end
 
@@ -96,7 +96,7 @@ class RequestMiddlewareTest < Faraday::TestCase
     response = @conn.post('/echo', payload)
 
     assert_kind_of Faraday::CompositeReadIO, response.body
-    assert_equal "multipart/form-data;boundary=%s" % Faraday::Request::Multipart::DEFAULT_BOUNDARY,
+    assert_equal "multipart/form-data; boundary=%s" % Faraday::Request::Multipart::DEFAULT_BOUNDARY,
       response.headers['Content-Type']
 
     response.body.send(:ios).map{|io| io.read}.each do |io|
@@ -106,7 +106,7 @@ class RequestMiddlewareTest < Faraday::TestCase
     end
     assert_equal [], regexes
   end
-  
+
   def test_multipart_with_arrays
     # assume params are out of order
     regexes = [
@@ -118,7 +118,7 @@ class RequestMiddlewareTest < Faraday::TestCase
     response = @conn.post('/echo', payload)
 
     assert_kind_of Faraday::CompositeReadIO, response.body
-    assert_equal "multipart/form-data;boundary=%s" % Faraday::Request::Multipart::DEFAULT_BOUNDARY,
+    assert_equal "multipart/form-data; boundary=%s" % Faraday::Request::Multipart::DEFAULT_BOUNDARY,
       response.headers['Content-Type']
 
     response.body.send(:ios).map{|io| io.read}.each do |io|
@@ -128,5 +128,5 @@ class RequestMiddlewareTest < Faraday::TestCase
     end
     assert_equal [], regexes
   end
-  
+
 end

data/test/utils_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestUtils < Faraday::TestCase
+
+  # emulates ActiveSupport::SafeBuffer#gsub
+  FakeSafeBuffer = Struct.new(:string) do
+    def to_s() self end
+    def gsub(regex)
+      string.gsub(regex) {
+        match, = $&, '' =~ /a/
+        yield match
+      }
+    end
+  end
+
+  def test_escaping_safe_buffer
+    str = FakeSafeBuffer.new('$32,000.00')
+    assert_equal '%2432%2C000.00', Faraday::Utils.escape(str)
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.8.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-24 00:00:00.000000000 Z
+date: 2013-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -119,6 +119,11 @@ files:
 - test/middleware_stack_test.rb
 - test/request_middleware_test.rb
 - test/response_middleware_test.rb
+- test/utils_test.rb
+- test/multibyte.txt
+- script/generate_certs
+- script/proxy-server
+- script/server
 - script/test
 homepage: https://github.com/lostisland/faraday
 licenses: