excon 0.62.0 → 0.92.3

data/tests/proxy_tests.rb

@@ -1,306 +0,0 @@
-Shindo.tests('Excon proxy support') do
-  env_init
-
-  tests('proxy configuration') do
-
-    tests('no proxy') do
-      tests('connection.data[:proxy]').returns(nil) do
-        connection = Excon.new('http://foo.com')
-        connection.data[:proxy]
-      end
-    end
-
-    tests('empty proxy') do
-      tests('connection.data[:proxy]').returns(nil) do
-        connection = Excon.new('http://foo.com', :proxy => '')
-        connection.data[:proxy]
-      end
-    end
-
-    tests('with fully-specified proxy: https://myproxy.net:8080') do
-      connection = nil
-
-      tests('connection.data[:proxy][:host]').returns('myproxy.net') do
-        connection = Excon.new('http://foo.com', :proxy => 'https://myproxy.net:8080')
-        connection.data[:proxy][:host]
-      end
-
-      tests('connection.data[:proxy][:port]').returns(8080) do
-        connection.data[:proxy][:port]
-      end
-
-      tests('connection.data[:proxy][:scheme]').returns('https') do
-        connection.data[:proxy][:scheme]
-      end
-    end
-
-    tests('with fully-specified Unix socket proxy: unix:///') do
-      connection = nil
-
-      tests('connection.data[:proxy][:host]').returns(nil) do
-        connection = Excon.new('http://foo.com', :proxy => 'unix:///tmp/myproxy.sock')
-        connection.data[:proxy][:host]
-      end
-
-      tests('connection.data[:proxy][:port]').returns(nil) do
-        connection.data[:proxy][:port]
-      end
-
-      tests('connection.data[:proxy][:scheme]').returns('unix') do
-        connection.data[:proxy][:scheme]
-      end
-
-      tests('connection.data[:proxy][:path]').returns('/tmp/myproxy.sock') do
-        connection.data[:proxy][:path]
-      end
-    end
-
-    def env_proxy_tests(env)
-      env_init(env)
-
-      tests('an http connection') do
-        connection = nil
-
-        tests('connection.data[:proxy][:host]').returns('myproxy') do
-          connection = Excon.new('http://foo.com')
-          connection.data[:proxy][:host]
-        end
-
-        tests('connection.data[:proxy][:port]').returns(8080) do
-          connection.data[:proxy][:port]
-        end
-
-        tests('connection.data[:proxy][:scheme]').returns('http') do
-          connection.data[:proxy][:scheme]
-        end
-
-        tests('with disable_proxy set') do
-          connection = nil
-
-          tests('connection.data[:proxy]').returns(nil) do
-            connection = Excon.new('http://foo.com', :disable_proxy => true)
-            connection.data[:proxy]
-          end
-        end
-      end
-
-      tests('an https connection') do
-        connection = nil
-
-        tests('connection.data[:proxy][:host]').returns('mysecureproxy') do
-          connection = Excon.new('https://secret.com')
-          connection.data[:proxy][:host]
-        end
-
-        tests('connection.data[:proxy][:port]').returns(8081) do
-          connection.data[:proxy][:port]
-        end
-
-        tests('connection.data[:proxy][:scheme]').returns('http') do
-          connection.data[:proxy][:scheme]
-        end
-
-        tests('with disable_proxy set') do
-          connection = nil
-
-          tests('connection.data[:proxy]').returns(nil) do
-            connection = Excon.new('https://foo.com', :disable_proxy => true)
-            connection.data[:proxy]
-          end
-        end
-      end
-
-      tests('http proxy from the environment overrides config') do
-        connection = nil
-
-        tests('connection.data[:proxy][:host]').returns('myproxy') do
-          connection = Excon.new('http://foo.com', :proxy => 'http://hard.coded.proxy:6666')
-          connection.data[:proxy][:host]
-        end
-
-        tests('connection.data[:proxy][:port]').returns(8080) do
-          connection.data[:proxy][:port]
-        end
-      end
-
-      tests('an http connection in no_proxy') do
-        tests('connection.data[:proxy]').returns(nil) do
-          connection = Excon.new('http://somesubdomain.noproxy')
-          connection.data[:proxy]
-        end
-      end
-
-      tests('an http connection not completely matching no_proxy') do
-        tests('connection.data[:proxy][:host]').returns('myproxy') do
-          connection = Excon.new('http://noproxy2')
-          connection.data[:proxy][:host]
-        end
-      end
-
-      tests('an http connection with subdomain in no_proxy') do
-        tests('connection.data[:proxy]').returns(nil) do
-          connection = Excon.new('http://a.subdomain.noproxy2')
-          connection.data[:proxy]
-        end
-      end
-
-      env_restore
-    end
-
-    tests('with complete proxy config from the environment') do
-      env = {
-        'http_proxy' => 'http://myproxy:8080',
-        'https_proxy' => 'http://mysecureproxy:8081',
-        'no_proxy' => 'noproxy, subdomain.noproxy2'
-      }
-      tests('lowercase') { env_proxy_tests(env) }
-      upperenv = {}
-      env.each do |k, v|
-        upperenv[k.upcase] = v
-      end
-      tests('uppercase') { env_proxy_tests(upperenv) }
-    end
-
-    tests('with only http_proxy config from the environment') do
-      env_init({'http_proxy' => 'http://myproxy:8080' })
-
-      tests('an https connection') do
-        connection = nil
-
-        tests('connection.data[:proxy][:host]').returns('myproxy') do
-          connection = Excon.new('https://secret.com')
-          connection.data[:proxy][:host]
-        end
-
-        tests('connection.data[:proxy][:port]').returns(8080) do
-          connection.data[:proxy][:port]
-        end
-
-        tests('connection.data[:proxy][:scheme]').returns('http') do
-          connection.data[:proxy][:scheme]
-        end
-      end
-
-      env_restore
-    end
-
-    tests('with a unix socket proxy config from the environment') do
-      env_init({
-        'http_proxy' => 'unix:///tmp/myproxy.sock',
-      })
-
-      tests('an https connection') do
-        connection = nil
-
-        tests('connection.data[:proxy][:host]').returns(nil) do
-          connection = Excon.new('https://secret.com')
-          connection.data[:proxy][:host]
-        end
-
-        tests('connection.data[:proxy][:port]').returns(nil) do
-          connection.data[:proxy][:port]
-        end
-
-        tests('connection.data[:proxy][:scheme]').returns('unix') do
-          connection.data[:proxy][:scheme]
-        end
-
-        tests('connection.data[:proxy][:path]').returns('/tmp/myproxy.sock') do
-          connection.data[:proxy][:path]
-        end
-      end
-
-      env_restore
-    end
-
-  end
-
-  with_rackup('proxy.ru') do
-
-    tests('http proxying: http://foo.com:8080') do
-      response = nil
-
-      tests('response.status').returns(200) do
-        connection = Excon.new('http://foo.com:8080', :proxy => 'http://127.0.0.1:9292')
-        response = connection.request(:method => :get, :path => '/bar', :query => {:alpha => 'kappa'})
-
-        response.status
-      end
-
-      # must be absolute form for proxy requests
-      tests('sent Request URI').returns('http://foo.com:8080/bar?alpha=kappa') do
-        response.headers['Sent-Request-Uri']
-      end
-
-      tests('sent Sent-Host header').returns('foo.com:8080') do
-        response.headers['Sent-Host']
-      end
-
-      tests('sent Proxy-Connection header').returns('Keep-Alive') do
-        response.headers['Sent-Proxy-Connection']
-      end
-
-      tests('response.body (proxied content)').returns('proxied content') do
-        response.body
-      end
-    end
-
-    tests('http proxying: http://user:pass@foo.com:8080') do
-      response = nil
-
-      tests('response.status').returns(200) do
-        connection = Excon.new('http://foo.com:8080', :proxy => 'http://user:pass@127.0.0.1:9292')
-        response = connection.request(:method => :get, :path => '/bar', :query => {:alpha => 'kappa'})
-
-        response.status
-      end
-
-      # must be absolute form for proxy requests
-      tests('sent Request URI').returns('http://foo.com:8080/bar?alpha=kappa') do
-        response.headers['Sent-Request-Uri']
-      end
-
-      tests('sent Host header').returns('foo.com:8080') do
-        response.headers['Sent-Host']
-      end
-
-      tests('sent Proxy-Connection header').returns('Keep-Alive') do
-        response.headers['Sent-Proxy-Connection']
-      end
-
-      tests('response.body (proxied content)').returns('proxied content') do
-        response.body
-      end
-    end
-
-  end
-
-  with_unicorn('proxy.ru', 'unix:///tmp/myproxy.sock') do
-    pending if RUBY_PLATFORM == 'java' # need to find suitable server for jruby
-
-    tests('http proxying over unix socket: http://foo.com:8080') do
-      response = nil
-
-      tests('response.status').returns(200) do
-        connection = Excon.new('http://foo.com:8080', :proxy => 'unix:///tmp/myproxy.sock')
-        response = connection.request(:method => :get, :path => '/bar', :query => {:alpha => 'kappa'})
-
-        response.status
-      end
-
-      tests('sent Sent-Host header').returns('foo.com:8080') do
-        response.headers['Sent-Host']
-      end
-
-      tests('sent Proxy-Connection header').returns('Keep-Alive') do
-        response.headers['Sent-Proxy-Connection']
-      end
-
-      tests('response.body (proxied content)').returns('proxied content') do
-        response.body
-      end
-    end
-  end
-
-  env_restore
-end

data/tests/query_string_tests.rb

@@ -1,87 +0,0 @@
-Shindo.tests('Excon query string variants') do
-  with_rackup('query_string.ru') do
-    connection = Excon.new('http://127.0.0.1:9292')
-
-    tests(":query => {:foo => 'bar'}") do
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar'})
-      query_string = response.body[7..-1] # query string sent
-
-      tests("query string sent").returns('foo=bar') do
-        query_string
-      end
-    end
-
-    tests(":query => {:foo => nil}") do
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => nil})
-      query_string = response.body[7..-1] # query string sent
-
-      tests("query string sent").returns('foo') do
-        query_string
-      end
-    end
-
-    tests(":query => {:foo => 'bar', :me => nil}") do
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar', :me => nil})
-      query_string = response.body[7..-1] # query string sent
-
-      test("query string sent includes 'foo=bar'") do
-        query_string.split('&').include?('foo=bar')
-      end
-
-      test("query string sent includes 'me'") do
-        query_string.split('&').include?('me')
-      end
-    end
-
-    tests(":query => {:foo => 'bar', :me => 'too'}") do
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar', :me => 'too'})
-      query_string = response.body[7..-1] # query string sent
-
-      test("query string sent includes 'foo=bar'") do
-        query_string.split('&').include?('foo=bar')
-      end
-
-      test("query string sent includes 'me=too'") do
-        query_string.split('&').include?('me=too')
-      end
-    end
-
-    # You can use an atom or a string for the hash keys, what is shown here is emulating
-    # the Rails and PHP style of serializing a query array with a square brackets suffix.
-    tests(":query => {'foo[]' => ['bar', 'baz'], :me => 'too'}") do
-      response = connection.request(:method => :get, :path => '/query', :query => {'foo[]' => ['bar', 'baz'], :me => 'too'})
-      query_string = response.body[7..-1] # query string sent
-
-      test("query string sent includes 'foo%5B%5D=bar'") do
-        query_string.split('&').include?('foo%5B%5D=bar')
-      end
-
-      test("query string sent includes 'foo%5B%5D=baz'") do
-        query_string.split('&').include?('foo%5B%5D=baz')
-      end
-
-      test("query string sent includes 'me=too'") do
-        query_string.split('&').include?('me=too')
-      end
-    end
-
-    tests(":query => {'foo%=#' => 'bar%=#'}") do
-      response = connection.request(:method => :get, :path => '/query', :query => {'foo%=#' => 'bar%=#'})
-      query_string = response.body[7..-1] # query string sent
-
-      tests("query string sent").returns('foo%25%3D%23=bar%25%3D%23') do
-        query_string
-      end
-    end
-
-    tests(":query => {'foo%=#' => nil}") do
-      response = connection.request(:method => :get, :path => '/query', :query => {'foo%=#' => nil})
-      query_string = response.body[7..-1] # query string sent
-
-      tests("query string sent").returns('foo%25%3D%23') do
-        query_string
-      end
-    end
-
-  end
-end

data/tests/rackups/basic.rb

@@ -1,41 +0,0 @@
-require 'sinatra'
-require 'json'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class Basic < Sinatra::Base
-  set :environment, :production
-  enable :dump_errors
-
-  get('/content-length/:value') do |value|
-    headers("Custom" => "Foo: bar")
-    'x' * value.to_i
-  end
-
-  get('/headers') do
-    content_type :json
-    request.env.select{|key, _| key.start_with? 'HTTP_'}.to_json
-  end
-
-  post('/body-sink') do
-    request.body.read.size.to_s
-  end
-
-  post('/echo') do
-    echo
-  end
-
-  put('/echo') do
-    echo
-  end
-
-  get('/echo dirty') do
-    echo
-  end
-
-  private
-
-  def echo
-    request.body.read
-  end
-
-end

data/tests/rackups/basic.ru

@@ -1,3 +0,0 @@
-require File.join(File.dirname(__FILE__), 'basic')
-
-run Basic

data/tests/rackups/basic_auth.ru

@@ -1,14 +0,0 @@
-require File.join(File.dirname(__FILE__), 'basic')
-
-class BasicAuth < Basic
-  before do
-    auth ||= Rack::Auth::Basic::Request.new(request.env)
-    user, pass = auth.provided? && auth.basic? && auth.credentials
-    unless [user, pass] == ["test_user", "test_password"]
-      response['WWW-Authenticate'] = %(Basic realm="Restricted Area")
-      throw(:halt, [401, "Not authorized\n"])
-    end
-  end
-end
-
-run BasicAuth

data/tests/rackups/deflater.ru

@@ -1,4 +0,0 @@
-require File.join(File.dirname(__FILE__), 'basic')
-
-use Rack::Deflater
-run Basic

data/tests/rackups/proxy.ru

@@ -1,18 +0,0 @@
-require 'sinatra'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class App < Sinatra::Base
-  set :environment, :production
-  enable :dump_errors
-
-  get('*') do
-    headers(
-      "Sent-Request-Uri" => request.env['REQUEST_URI'].to_s,
-      "Sent-Host" => request.env['HTTP_HOST'].to_s,
-      "Sent-Proxy-Connection" => request.env['HTTP_PROXY_CONNECTION'].to_s
-    )
-    'proxied content'
-  end
-end
-
-run App

data/tests/rackups/query_string.ru

@@ -1,13 +0,0 @@
-require 'sinatra'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class App < Sinatra::Base
-  set :environment, :production
-  enable :dump_errors
-
-  get('/query') do
-    "query: " << request.query_string
-  end
-end
-
-run App

data/tests/rackups/redirecting.ru

@@ -1,23 +0,0 @@
-require 'sinatra'
-require 'json'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class App < Sinatra::Base
-  set :environment, :production
-  enable :dump_errors
-
-  post('/first') do
-    redirect "/second"
-  end
-
-  get('/second') do
-    post_body = request.body.read
-    if post_body == "" && request["CONTENT_LENGTH"].nil?
-      "ok"
-    else
-      JSON.pretty_generate(request.env)
-    end
-  end
-end
-
-run App

data/tests/rackups/redirecting_with_cookie.ru

@@ -1,40 +0,0 @@
-require 'sinatra'
-require 'sinatra/cookies'
-require 'json'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class App < Sinatra::Base
-  helpers Sinatra::Cookies
-  set :environment, :production
-  enable :dump_errors
-
-  get('/sets_cookie') do
-    cookies[:chocolatechip] = "chunky"
-    redirect "/requires_cookie"
-  end
-
-  get('/requires_cookie') do
-    cookie = cookies[:chocolatechip]
-    unless cookie.nil? || cookie != "chunky"
-      "ok"
-    else
-      JSON.pretty_generate(headers)
-    end
-  end
-  
-  get('/sets_multi_cookie') do
-    cookies[:chocolatechip] = "chunky"
-    cookies[:thinmints] = "minty"
-    redirect "/requires_cookie"
-  end
-
-  get('/requires_cookie') do
-    if cookies[:chocolatechip] == "chunky" && cookies[:thinmints] == "minty" 
-      "ok"
-    else
-      JSON.pretty_generate(headers)
-    end
-  end
-end
-
-run App

data/tests/rackups/request_headers.ru

@@ -1,15 +0,0 @@
-require 'sinatra'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class App < Sinatra::Base
-  set :environment, :production
-  enable :dump_errors
-
-  post '/' do
-    h = ""
-    env.each { |k,v| h << "#{$1.downcase}: #{v}\n" if k =~ /http_(.*)/i }
-    h
-  end
-end
-
-run App

data/tests/rackups/request_methods.ru

@@ -1,21 +0,0 @@
-require 'sinatra'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class App < Sinatra::Base
-  set :environment, :production
-  enable :dump_errors
-
-  get '/' do
-    'GET'
-  end
-
-  post '/' do
-    'POST'
-  end
-
-  delete '/' do
-    'DELETE'
-  end
-end
-
-run App

data/tests/rackups/response_header.ru

@@ -1,18 +0,0 @@
-require 'sinatra'
-require File.join(File.dirname(__FILE__), 'webrick_patch')
-
-class App < Sinatra::Base
-  set :environment, :production
-  enable :dump_errors
-
-  get('/foo') do
-    headers(
-      "MixedCase-Header" => 'MixedCase',
-      "UPPERCASE-HEADER" => 'UPPERCASE',
-      "lowercase-header" => 'lowercase'
-    )
-    'primary content'
-  end
-end
-
-run App

data/tests/rackups/ssl.ru

@@ -1,16 +0,0 @@
-require 'openssl'
-require 'webrick'
-require 'webrick/https'
-
-require File.join(File.dirname(__FILE__), 'basic')
-
-key_file = File.join(File.dirname(__FILE__), '..', 'data', '127.0.0.1.cert.key')
-cert_file = File.join(File.dirname(__FILE__), '..', 'data', '127.0.0.1.cert.crt')
-Rack::Handler::WEBrick.run(Basic, {
-  :Port             => 9443,
-  :SSLEnable        => true,
-  :SSLPrivateKey    => OpenSSL::PKey::RSA.new(File.open(key_file).read),
-  :SSLCertificate   => OpenSSL::X509::Certificate.new(File.open(cert_file).read),
-  :SSLCACertificateFile => cert_file,
-  :SSLVerifyClient  => OpenSSL::SSL::VERIFY_NONE,
-})

data/tests/rackups/ssl_mismatched_cn.ru

@@ -1,15 +0,0 @@
-require 'openssl'
-require 'webrick'
-require 'webrick/https'
-
-require File.join(File.dirname(__FILE__), 'basic')
-key_file = File.join(File.dirname(__FILE__), '..', 'data', 'excon.cert.key')
-cert_file = File.join(File.dirname(__FILE__), '..', 'data', 'excon.cert.crt')
-Rack::Handler::WEBrick.run(Basic, {
-  :Port             => 9443,
-  :SSLEnable        => true,
-  :SSLPrivateKey    => OpenSSL::PKey::RSA.new(File.open(key_file).read),
-  :SSLCertificate   => OpenSSL::X509::Certificate.new(File.open(cert_file).read),
-  :SSLCACertificateFile => cert_file,
-  :SSLVerifyClient  => OpenSSL::SSL::VERIFY_NONE,
-})

data/tests/rackups/ssl_verify_peer.ru

@@ -1,16 +0,0 @@
-require 'openssl'
-require 'webrick'
-require 'webrick/https'
-
-require File.join(File.dirname(__FILE__), 'basic')
-key_file = File.join(File.dirname(__FILE__), '..', 'data', 'excon.cert.key')
-cert_file = File.join(File.dirname(__FILE__), '..', 'data', 'excon.cert.crt')
-Rack::Handler::WEBrick.run(Basic, {
-  :Port             => 8443,
-  :SSLCertName      => [["CN", WEBrick::Utils::getservername]],
-  :SSLEnable        => true,
-  :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.open(key_file).read),
-  :SSLCertificate => OpenSSL::X509::Certificate.new(File.open(cert_file).read),
-  :SSLCACertificateFile => cert_file,
-  :SSLVerifyClient  => OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT,
-})