faraday 0.9.1 → 0.9.2

data/test/adapters/net_http_test.rb

@@ -1,14 +0,0 @@
-require File.expand_path('../integration', __FILE__)
-
-module Adapters
-  class NetHttpTest < Faraday::TestCase
-
-    def adapter() :net_http end
-
-    behaviors = [:NonParallel]
-    behaviors << :Compression if RUBY_VERSION >= '1.9'
-
-    Integration.apply(self, *behaviors)
-
-  end
-end

data/test/adapters/patron_test.rb

@@ -1,20 +0,0 @@
-require File.expand_path('../integration', __FILE__)
-
-module Adapters
-  class Patron < Faraday::TestCase
-
-    def adapter() :patron end
-
-    Integration.apply(self, :NonParallel) do
-      # https://github.com/toland/patron/issues/34
-      undef :test_PATCH_send_url_encoded_params
-
-      # https://github.com/toland/patron/issues/52
-      undef :test_GET_with_body
-
-      # no support for SSL peer verification
-      undef :test_GET_ssl_fails_with_bad_cert if ssl_mode?
-    end unless jruby?
-
-  end
-end

data/test/adapters/rack_test.rb

@@ -1,31 +0,0 @@
-require File.expand_path("../integration", __FILE__)
-require File.expand_path('../../live_server', __FILE__)
-
-module Adapters
-  class RackTest < Faraday::TestCase
-
-    def adapter() :rack end
-
-    def adapter_options
-      [Faraday::LiveServer]
-    end
-
-    # no Integration.apply because this doesn't require a server as a separate process
-    include Integration::Common
-    include Integration::NonParallel
-
-    # not using shared test because error is swallowed by Sinatra
-    def test_timeout
-      conn = create_connection(:request => {:timeout => 1, :open_timeout => 1})
-      begin
-        conn.get '/slow'
-      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/test_middleware_test.rb

@@ -1,114 +0,0 @@
-require File.expand_path('../../helper', __FILE__)
-
-module Adapters
-  class TestMiddleware < Faraday::TestCase
-    Stubs = Faraday::Adapter.lookup_middleware(:test)::Stubs
-    def setup
-      @stubs = Stubs.new
-      @conn  = Faraday.new do |builder|
-        builder.adapter :test, @stubs
-      end
-      @stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'hello'] }
-      @resp = @conn.get('/hello')
-    end
-
-    def test_middleware_with_simple_path_sets_status
-      assert_equal 200, @resp.status
-    end
-
-    def test_middleware_with_simple_path_sets_headers
-      assert_equal 'text/html', @resp.headers['Content-Type']
-    end
-
-    def test_middleware_with_simple_path_sets_body
-      assert_equal 'hello', @resp.body
-    end
-
-    def test_middleware_can_be_called_several_times
-      assert_equal 'hello', @conn.get("/hello").body
-    end
-
-    def test_middleware_with_get_params
-      @stubs.get('/param?a=1') { [200, {}, 'a'] }
-      assert_equal 'a', @conn.get('/param?a=1').body
-    end
-
-    def test_middleware_ignores_unspecified_get_params
-      @stubs.get('/optional?a=1') { [200, {}, 'a'] }
-      assert_equal 'a', @conn.get('/optional?a=1&b=1').body
-      assert_equal 'a', @conn.get('/optional?a=1').body
-      assert_raises Faraday::Adapter::Test::Stubs::NotFound do
-        @conn.get('/optional')
-      end
-    end
-
-    def test_middleware_with_http_headers
-      @stubs.get('/yo', { 'X-HELLO' => 'hello' }) { [200, {}, 'a'] }
-      @stubs.get('/yo') { [200, {}, 'b'] }
-      assert_equal 'a', @conn.get('/yo') { |env| env.headers['X-HELLO'] = 'hello' }.body
-      assert_equal 'b', @conn.get('/yo').body
-    end
-
-    def test_middleware_allow_different_outcomes_for_the_same_request
-      @stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'hello'] }
-      @stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'world'] }
-      assert_equal 'hello', @conn.get("/hello").body
-      assert_equal 'world', @conn.get("/hello").body
-    end
-
-    def test_yields_env_to_stubs
-      @stubs.get '/hello' do |env|
-        assert_equal '/hello',     env[:url].path
-        assert_equal 'foo.com',    env[:url].host
-        assert_equal '1',          env[:params]['a']
-        assert_equal 'text/plain', env[:request_headers]['Accept']
-        [200, {}, 'a']
-      end
-
-      @conn.headers['Accept'] = 'text/plain'
-      assert_equal 'a', @conn.get('http://foo.com/hello?a=1').body
-    end
-
-    def test_parses_params_with_default_encoder
-      @stubs.get '/hello' do |env|
-        assert_equal '1', env[:params]['a']['b']
-        [200, {}, 'a']
-      end
-
-      assert_equal 'a', @conn.get('http://foo.com/hello?a[b]=1').body
-    end
-
-    def test_parses_params_with_nested_encoder
-      @stubs.get '/hello' do |env|
-        assert_equal '1', env[:params]['a']['b']
-        [200, {}, 'a']
-      end
-
-      @conn.options.params_encoder = Faraday::NestedParamsEncoder
-      assert_equal 'a', @conn.get('http://foo.com/hello?a[b]=1').body
-    end
-
-    def test_parses_params_with_flat_encoder
-      @stubs.get '/hello' do |env|
-        assert_equal '1', env[:params]['a[b]']
-        [200, {}, 'a']
-      end
-
-      @conn.options.params_encoder = Faraday::FlatParamsEncoder
-      assert_equal 'a', @conn.get('http://foo.com/hello?a[b]=1').body
-    end
-
-    def test_raises_an_error_if_no_stub_is_found_for_request
-      assert_raises Stubs::NotFound do
-        @conn.get('/invalid'){ [200, {}, []] }
-      end
-    end
-
-    def test_raises_an_error_if_no_stub_is_found_for_request_without_this_header
-      @stubs.get('/yo', { 'X-HELLO' => 'hello' }) { [200, {}, 'a'] }
-      assert_raises Faraday::Adapter::Test::Stubs::NotFound do
-        @conn.get('/yo')
-      end
-    end
-  end
-end

data/test/adapters/typhoeus_test.rb

@@ -1,28 +0,0 @@
-require File.expand_path('../integration', __FILE__)
-
-module Adapters
-  class TyphoeusTest < Faraday::TestCase
-
-    def adapter() :typhoeus end
-
-    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?
-
-      def test_binds_local_socket
-        host = '1.2.3.4'
-        conn = create_connection :request => { :bind => { :host => host } }
-        assert_equal host, conn.options[:bind][:host]
-      end
-
-    end unless jruby?
-  end
-end
-

data/test/authentication_middleware_test.rb

@@ -1,65 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class AuthenticationMiddlewareTest < Faraday::TestCase
-  def conn
-    Faraday::Connection.new('http://example.net/') do |builder|
-      yield(builder)
-      builder.adapter :test do |stub|
-        stub.get('/auth-echo') do |env|
-          [200, {}, env[:request_headers]['Authorization']]
-        end
-      end
-    end
-  end
-
-  def test_basic_middleware_adds_basic_header
-    response = conn { |b| b.request :basic_auth, 'aladdin', 'opensesame' }.get('/auth-echo')
-    assert_equal 'Basic YWxhZGRpbjpvcGVuc2VzYW1l', response.body
-  end
-
-  def test_basic_middleware_adds_basic_header_correctly_with_long_values
-    response = conn { |b| b.request :basic_auth, 'A' * 255, '' }.get('/auth-echo')
-    assert_equal "Basic #{'QUFB' * 85}Og==", response.body
-  end
-
-  def test_basic_middleware_does_not_interfere_with_existing_authorization
-    response = conn { |b| b.request :basic_auth, 'aladdin', 'opensesame' }.
-      get('/auth-echo', nil, :authorization => 'Token token="bar"')
-    assert_equal 'Token token="bar"', response.body
-  end
-
-  def test_token_middleware_adds_token_header
-    response = conn { |b| b.request :token_auth, 'quux' }.get('/auth-echo')
-    assert_equal 'Token token="quux"', response.body
-  end
-
-  def test_token_middleware_includes_other_values_if_provided
-    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)
-  end
-
-  def test_token_middleware_does_not_interfere_with_existing_authorization
-    response = conn { |b| b.request :token_auth, 'quux' }.
-      get('/auth-echo', nil, :authorization => 'Token token="bar"')
-    assert_equal 'Token token="bar"', response.body
-  end
-
-  def test_authorization_middleware_with_string
-    response = conn { |b|
-      b.request :authorization, 'custom', 'abc def'
-    }.get('/auth-echo')
-    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)
-  end
-end

data/test/composite_read_io_test.rb

@@ -1,111 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'stringio'
-
-class CompositeReadIOTest < Faraday::TestCase
-  Part = Struct.new(:to_io) do
-    def length() to_io.string.length end
-  end
-
-  def part(str)
-    Part.new StringIO.new(str)
-  end
-
-  def composite_io(*parts)
-    Faraday::CompositeReadIO.new(*parts)
-  end
-
-  def test_empty
-    io = composite_io
-    assert_equal 0, io.length
-    assert_equal "", io.read
-  end
-
-  def test_empty_returns_nil_for_limited_read
-    assert_nil composite_io.read(1)
-  end
-
-  def test_empty_parts_returns_nil_for_limited_read
-    io = composite_io(part(""), part(""))
-    assert_nil io.read(1)
-  end
-
-  def test_multipart_read_all
-    io = composite_io(part("abcd"), part("1234"))
-    assert_equal 8, io.length
-    assert_equal "abcd1234", io.read
-  end
-
-  def test_multipart_read_limited
-    io = composite_io(part("abcd"), part("1234"))
-    assert_equal "abc", io.read(3)
-    assert_equal "d12", io.read(3)
-    assert_equal "34", io.read(3)
-    assert_equal nil, io.read(3)
-    assert_equal nil, io.read(3)
-  end
-
-  def test_multipart_read_limited_size_larger_than_part
-    io = composite_io(part("abcd"), part("1234"))
-    assert_equal "abcd12", io.read(6)
-    assert_equal "34", io.read(6)
-    assert_equal nil, io.read(6)
-  end
-
-  def test_multipart_read_with_blank_parts
-    io = composite_io(part(""), part("abcd"), part(""), part("1234"), part(""))
-    assert_equal "abcd12", io.read(6)
-    assert_equal "34", io.read(6)
-    assert_equal nil, io.read(6)
-  end
-
-  def test_multipart_rewind
-    io = composite_io(part("abcd"), part("1234"))
-    assert_equal "abc", io.read(3)
-    assert_equal "d12", io.read(3)
-    io.rewind
-    assert_equal "abc", io.read(3)
-    assert_equal "d1234", io.read(5)
-    assert_equal nil, io.read(3)
-    io.rewind
-    assert_equal "ab", io.read(2)
-  end
-
-  # JRuby enforces types to copy_stream to be String or IO
-  if IO.respond_to?(:copy_stream) && !jruby?
-    def test_compatible_with_copy_stream
-      target_io = StringIO.new
-      def target_io.ensure_open_and_writable
-        # Rubinius compatibility
-      end
-      io = composite_io(part("abcd"), part("1234"))
-
-      Faraday::Timer.timeout(1) do
-        IO.copy_stream(io, target_io)
-      end
-      assert_equal "abcd1234", target_io.string
-    end
-  end
-
-  unless RUBY_VERSION < '1.9'
-    def test_read_from_multibyte
-      File.open(File.dirname(__FILE__) + '/multibyte.txt') do |utf8|
-        io = composite_io(part("\x86"), Part.new(utf8))
-        assert_equal bin("\x86\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\n"), io.read
-      end
-    end
-
-    def test_limited_from_multibyte
-      File.open(File.dirname(__FILE__) + '/multibyte.txt') do |utf8|
-        io = composite_io(part("\x86"), Part.new(utf8))
-        assert_equal bin("\x86\xE3\x83"), io.read(3)
-        assert_equal bin("\x95\xE3\x82"), io.read(3)
-        assert_equal bin("\xA1\xE3\x82\xA4\xE3\x83\xAB\n"), io.read(8)
-      end
-    end
-  end
-
-  def bin(str)
-    str.force_encoding("BINARY") if str.respond_to?(:force_encoding)
-    str
-  end
-end

data/test/connection_test.rb

@@ -1,522 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestConnection < Faraday::TestCase
-
-  def with_env(key, proxy)
-    old_value = ENV.fetch(key, false)
-    ENV[key] = proxy
-    begin
-      yield
-    ensure
-      if old_value == false
-        ENV.delete key
-      else
-        ENV[key] = old_value
-      end
-    end
-  end
-
-  def test_initialize_parses_host_out_of_given_url
-    conn = Faraday::Connection.new "http://sushi.com"
-    assert_equal 'sushi.com', conn.host
-  end
-
-  def test_initialize_inherits_default_port_out_of_given_url
-    conn = Faraday::Connection.new "http://sushi.com"
-    assert_equal 80, conn.port
-  end
-
-  def test_initialize_parses_scheme_out_of_given_url
-    conn = Faraday::Connection.new "http://sushi.com"
-    assert_equal 'http', conn.scheme
-  end
-
-  def test_initialize_parses_port_out_of_given_url
-    conn = Faraday::Connection.new "http://sushi.com:815"
-    assert_equal 815, conn.port
-  end
-
-  def test_initialize_parses_nil_path_prefix_out_of_given_url
-    conn = Faraday::Connection.new "http://sushi.com"
-    assert_equal '/', conn.path_prefix
-  end
-
-  def test_initialize_parses_path_prefix_out_of_given_url
-    conn = Faraday::Connection.new "http://sushi.com/fish"
-    assert_equal '/fish', conn.path_prefix
-  end
-
-  def test_initialize_parses_path_prefix_out_of_given_url_option
-    conn = Faraday::Connection.new :url => "http://sushi.com/fish"
-    assert_equal '/fish', conn.path_prefix
-  end
-
-  def test_initialize_stores_default_params_from_options
-    conn = Faraday::Connection.new :params => {:a => 1}
-    assert_equal({'a' => 1}, conn.params)
-  end
-
-  def test_initialize_stores_default_params_from_uri
-    conn = Faraday::Connection.new "http://sushi.com/fish?a=1"
-    assert_equal({'a' => '1'}, conn.params)
-  end
-
-  def test_initialize_stores_default_params_from_uri_and_options
-    conn = Faraday::Connection.new "http://sushi.com/fish?a=1&b=2", :params => {'a' => 3}
-    assert_equal({'a' => 3, 'b' => '2'}, conn.params)
-  end
-
-  def test_initialize_stores_default_headers_from_options
-    conn = Faraday::Connection.new :headers => {:user_agent => 'Faraday'}
-    assert_equal 'Faraday', conn.headers['User-agent']
-  end
-
-  def test_basic_auth_sets_header
-    conn = Faraday::Connection.new
-    assert_nil conn.headers['Authorization']
-
-    conn.basic_auth 'Aladdin', 'open sesame'
-    assert auth = conn.headers['Authorization']
-    assert_equal 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==', auth
-  end
-
-  def test_auto_parses_basic_auth_from_url_and_unescapes
-    conn = Faraday::Connection.new :url => "http://foo%40bar.com:pass%20word@sushi.com/fish"
-    assert auth = conn.headers['Authorization']
-    assert_equal Faraday::Request::BasicAuthentication.header("foo@bar.com", "pass word"), auth
-  end
-
-  def test_token_auth_sets_header
-    conn = Faraday::Connection.new
-    assert_nil conn.headers['Authorization']
-
-    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)
-  end
-
-  def test_build_exclusive_url_uses_connection_host_as_default_uri_host
-    conn = Faraday::Connection.new
-    conn.host = 'sushi.com'
-    uri = conn.build_exclusive_url("/sake.html")
-    assert_equal 'sushi.com', uri.host
-  end
-
-  def test_build_exclusive_url_overrides_connection_port_for_absolute_urls
-    conn = Faraday::Connection.new
-    conn.port = 23
-    uri = conn.build_exclusive_url("http://sushi.com")
-    assert_equal 80, uri.port
-  end
-
-  def test_build_exclusive_url_uses_connection_scheme_as_default_uri_scheme
-    conn = Faraday::Connection.new 'http://sushi.com'
-    uri = conn.build_exclusive_url("/sake.html")
-    assert_equal 'http', uri.scheme
-  end
-
-  def test_build_exclusive_url_uses_connection_path_prefix_to_customize_path
-    conn = Faraday::Connection.new
-    conn.path_prefix = '/fish'
-    uri = conn.build_exclusive_url("sake.html")
-    assert_equal '/fish/sake.html', uri.path
-  end
-
-  def test_build_exclusive_url_uses_root_connection_path_prefix_to_customize_path
-    conn = Faraday::Connection.new
-    conn.path_prefix = '/'
-    uri = conn.build_exclusive_url("sake.html")
-    assert_equal '/sake.html', uri.path
-  end
-
-  def test_build_exclusive_url_forces_connection_path_prefix_to_be_absolute
-    conn = Faraday::Connection.new
-    conn.path_prefix = 'fish'
-    uri = conn.build_exclusive_url("sake.html")
-    assert_equal '/fish/sake.html', uri.path
-  end
-
-  def test_build_exclusive_url_ignores_connection_path_prefix_trailing_slash
-    conn = Faraday::Connection.new
-    conn.path_prefix = '/fish/'
-    uri = conn.build_exclusive_url("sake.html")
-    assert_equal '/fish/sake.html', uri.path
-  end
-
-  def test_build_exclusive_url_allows_absolute_uri_to_ignore_connection_path_prefix
-    conn = Faraday::Connection.new
-    conn.path_prefix = '/fish'
-    uri = conn.build_exclusive_url("/sake.html")
-    assert_equal '/sake.html', uri.path
-  end
-
-  def test_build_exclusive_url_parses_url_params_into_path
-    conn = Faraday::Connection.new
-    uri = conn.build_exclusive_url("http://sushi.com/sake.html")
-    assert_equal '/sake.html', uri.path
-  end
-
-  def test_build_exclusive_url_doesnt_add_ending_slash_given_nil_url
-    conn = Faraday::Connection.new
-    conn.url_prefix = "http://sushi.com/nigiri"
-    uri = conn.build_exclusive_url
-    assert_equal "/nigiri", uri.path
-  end
-
-  def test_build_exclusive_url_doesnt_add_ending_slash_given_empty_url
-    conn = Faraday::Connection.new
-    conn.url_prefix = "http://sushi.com/nigiri"
-    uri = conn.build_exclusive_url('')
-    assert_equal "/nigiri", uri.path
-  end
-
-  def test_build_exclusive_url_doesnt_use_connection_params
-    conn = Faraday::Connection.new "http://sushi.com/nigiri"
-    conn.params = {:a => 1}
-    assert_equal "http://sushi.com/nigiri", conn.build_exclusive_url.to_s
-  end
-
-  def test_build_exclusive_url_uses_argument_params
-    conn = Faraday::Connection.new "http://sushi.com/nigiri"
-    conn.params = {:a => 1}
-    params = Faraday::Utils::ParamsHash.new
-    params[:a] = 2
-    url = conn.build_exclusive_url(nil, params)
-    assert_equal "http://sushi.com/nigiri?a=2", url.to_s
-  end
-
-  def test_build_url_uses_params
-    conn = Faraday::Connection.new "http://sushi.com/nigiri"
-    conn.params = {:a => 1, :b => 1}
-    assert_equal "http://sushi.com/nigiri?a=1&b=1", conn.build_url.to_s
-  end
-
-  def test_build_url_merges_params
-    conn = Faraday::Connection.new "http://sushi.com/nigiri"
-    conn.params = {:a => 1, :b => 1}
-    url = conn.build_url(nil, :b => 2, :c => 3)
-    assert_equal "http://sushi.com/nigiri?a=1&b=2&c=3", url.to_s
-  end
-
-  def test_env_url_parses_url_params_into_query
-    uri = env_url("http://sushi.com/sake.html", 'a[b]' => '1 + 2')
-    assert_equal "a%5Bb%5D=1+%2B+2", uri.query
-  end
-
-  def test_env_url_escapes_per_spec
-    uri = env_url('http:/', 'a' => '1+2 foo~bar.-baz')
-    assert_equal "a=1%2B2+foo~bar.-baz", uri.query
-  end
-
-  def test_env_url_bracketizes_nested_params_in_query
-    url = env_url nil, 'a' => {'b' => 'c'}
-    assert_equal "a%5Bb%5D=c", url.query
-  end
-
-  def test_env_url_bracketizes_repeated_params_in_query
-    uri = env_url("http://sushi.com/sake.html", 'a' => [1, 2])
-    assert_equal "a%5B%5D=1&a%5B%5D=2", uri.query
-  end
-
-  def test_env_url_without_braketizing_repeated_params_in_query
-    uri = env_url 'http://sushi.com', 'a' => [1, 2] do |conn|
-      conn.options.params_encoder = Faraday::FlatParamsEncoder
-    end
-    assert_equal "a=1&a=2", uri.query
-  end
-
-  def test_build_exclusive_url_parses_url
-    conn = Faraday::Connection.new
-    uri = conn.build_exclusive_url("http://sushi.com/sake.html")
-    assert_equal "http",       uri.scheme
-    assert_equal "sushi.com",  uri.host
-    assert_equal '/sake.html', uri.path
-  end
-
-  def test_build_exclusive_url_parses_url_and_changes_scheme
-    conn = Faraday::Connection.new :url => "http://sushi.com/sushi"
-    conn.scheme = 'https'
-    uri = conn.build_exclusive_url("sake.html")
-    assert_equal 'https://sushi.com/sushi/sake.html', uri.to_s
-  end
-
-  def test_build_exclusive_url_joins_url_to_base_with_ending_slash
-    conn = Faraday::Connection.new :url => "http://sushi.com/sushi/"
-    uri = conn.build_exclusive_url("sake.html")
-    assert_equal 'http://sushi.com/sushi/sake.html', uri.to_s
-  end
-
-  def test_build_exclusive_url_used_default_base_with_ending_slash
-    conn = Faraday::Connection.new :url => "http://sushi.com/sushi/"
-    uri = conn.build_exclusive_url
-    assert_equal 'http://sushi.com/sushi/', uri.to_s
-  end
-
-  def test_build_exclusive_url_overrides_base
-    conn = Faraday::Connection.new :url => "http://sushi.com/sushi/"
-    uri = conn.build_exclusive_url('/sake/')
-    assert_equal 'http://sushi.com/sake/', uri.to_s
-  end
-
-  def test_build_exclusive_url_handles_uri_instances
-    conn = Faraday::Connection.new
-    uri = conn.build_exclusive_url(URI('/sake.html'))
-    assert_equal '/sake.html', uri.path
-  end
-
-  def test_proxy_accepts_string
-    with_env 'http_proxy', "http://duncan.proxy.com:80" do
-      conn = Faraday::Connection.new
-      conn.proxy 'http://proxy.com'
-      assert_equal 'proxy.com', conn.proxy.host
-    end
-  end
-
-  def test_proxy_accepts_uri
-    with_env 'http_proxy', "http://duncan.proxy.com:80" do
-      conn = Faraday::Connection.new
-      conn.proxy URI.parse('http://proxy.com')
-      assert_equal 'proxy.com', conn.proxy.host
-    end
-  end
-
-  def test_proxy_accepts_hash_with_string_uri
-    with_env 'http_proxy', "http://duncan.proxy.com:80" do
-      conn = Faraday::Connection.new
-      conn.proxy :uri => 'http://proxy.com', :user => 'rick'
-      assert_equal 'proxy.com', conn.proxy.host
-      assert_equal 'rick',      conn.proxy.user
-    end
-  end
-
-  def test_proxy_accepts_hash
-    with_env 'http_proxy', "http://duncan.proxy.com:80" do
-      conn = Faraday::Connection.new
-      conn.proxy :uri => URI.parse('http://proxy.com'), :user => 'rick'
-      assert_equal 'proxy.com', conn.proxy.host
-      assert_equal 'rick',      conn.proxy.user
-    end
-  end
-
-  def test_proxy_accepts_http_env
-    with_env 'http_proxy', "http://duncan.proxy.com:80" do
-      conn = Faraday::Connection.new
-      assert_equal 'duncan.proxy.com', conn.proxy.host
-    end
-  end
-
-  def test_proxy_accepts_http_env_with_auth
-    with_env 'http_proxy', "http://a%40b:my%20pass@duncan.proxy.com:80" do
-      conn = Faraday::Connection.new
-      assert_equal 'a@b',     conn.proxy.user
-      assert_equal 'my pass', conn.proxy.password
-    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
-      conn.proxy :uri => :bad_uri, :user => 'rick'
-    end
-  end
-
-  def test_dups_connection_object
-    conn = Faraday::Connection.new 'http://sushi.com/foo',
-      :ssl => { :verify => :none },
-      :headers => {'content-type' => 'text/plain'},
-      :params => {'a'=>'1'}
-
-    other = conn.dup
-
-    assert_equal conn.build_exclusive_url, other.build_exclusive_url
-    assert_equal 'text/plain', other.headers['content-type']
-    assert_equal '1', other.params['a']
-
-    other.basic_auth('', '')
-    other.headers['content-length'] = 12
-    other.params['b'] = '2'
-
-    assert_equal 2, other.builder.handlers.size
-    assert_equal 2, conn.builder.handlers.size
-    assert !conn.headers.key?('content-length')
-    assert !conn.params.key?('b')
-  end
-
-  def test_initialize_with_false_option
-    conn = Faraday::Connection.new :ssl => {:verify => false}
-    assert !conn.ssl.verify?
-  end
-
-  def test_init_with_block
-    conn = Faraday::Connection.new { }
-    assert_equal 0, conn.builder.handlers.size
-  end
-
-  def test_init_with_block_yields_connection
-    conn = Faraday::Connection.new(:params => {'a'=>'1'}) { |faraday|
-      faraday.adapter :net_http
-      faraday.url_prefix = 'http://sushi.com/omnom'
-      assert_equal '1', faraday.params['a']
-    }
-    assert_equal 1, conn.builder.handlers.size
-    assert_equal '/omnom', conn.path_prefix
-  end
-
-  def env_url(url, params)
-    conn = Faraday::Connection.new(url, :params => params)
-    yield(conn) if block_given?
-    req = conn.build_request(:get)
-    req.to_env(conn).url
-  end
-end
-
-class TestRequestParams < Faraday::TestCase
-  def create_connection(*args)
-    @conn = Faraday::Connection.new(*args) do |conn|
-      yield(conn) if block_given?
-      class << conn.builder
-        undef app
-        def app() lambda { |env| env } end
-      end
-    end
-  end
-
-  def assert_query_equal(expected, query)
-    assert_equal expected, query.split('&').sort
-  end
-
-  def with_default_params_encoder(encoder)
-    old_encoder = Faraday::Utils.default_params_encoder
-    begin
-      Faraday::Utils.default_params_encoder = encoder
-      yield
-    ensure
-      Faraday::Utils.default_params_encoder = old_encoder
-    end
-  end
-
-  def test_merges_connection_and_request_params
-    create_connection 'http://a.co/?token=abc', :params => {'format' => 'json'}
-    query = get '?page=1', :limit => 5
-    assert_query_equal %w[format=json limit=5 page=1 token=abc], query
-  end
-
-  def test_overrides_connection_params
-    create_connection 'http://a.co/?a=a&b=b&c=c', :params => {:a => 'A'} do |conn|
-      conn.params[:b] = 'B'
-      assert_equal 'c', conn.params[:c]
-    end
-    assert_query_equal %w[a=A b=B c=c], get
-  end
-
-  def test_all_overrides_connection_params
-    create_connection 'http://a.co/?a=a', :params => {:c => 'c'} do |conn|
-      conn.params = {'b' => 'b'}
-    end
-    assert_query_equal %w[b=b], get
-  end
-
-  def test_overrides_request_params
-    create_connection
-    query = get '?p=1&a=a', :p => 2
-    assert_query_equal %w[a=a p=2], query
-  end
-
-  def test_overrides_request_params_block
-    create_connection
-    query = get '?p=1&a=a', :p => 2 do |req|
-      req.params[:p] = 3
-    end
-    assert_query_equal %w[a=a p=3], query
-  end
-
-  def test_overrides_request_params_block_url
-    create_connection
-    query = get nil, :p => 2 do |req|
-      req.url '?p=1&a=a', 'p' => 3
-    end
-    assert_query_equal %w[a=a p=3], query
-  end
-
-  def test_overrides_all_request_params
-    create_connection :params => {:c => 'c'}
-    query = get '?p=1&a=a', :p => 2 do |req|
-      assert_equal 'a', req.params[:a]
-      assert_equal 'c', req.params['c']
-      assert_equal 2, req.params['p']
-      req.params = {:b => 'b'}
-      assert_equal 'b', req.params['b']
-    end
-    assert_query_equal %w[b=b], query
-  end
-
-  def test_array_params_in_url
-    with_default_params_encoder(nil) do
-      create_connection 'http://a.co/page1?color[]=red&color[]=blue'
-      query = get
-      assert_equal "color%5B%5D=red&color%5B%5D=blue", query
-    end
-  end
-
-  def test_array_params_in_params
-    with_default_params_encoder(nil) do
-      create_connection 'http://a.co/page1', :params => {:color => ['red', 'blue']}
-      query = get
-      assert_equal "color%5B%5D=red&color%5B%5D=blue", query
-    end
-  end
-
-  def test_array_params_in_url_with_flat_params
-    with_default_params_encoder(Faraday::FlatParamsEncoder) do
-      create_connection 'http://a.co/page1?color=red&color=blue'
-      query = get
-      assert_equal "color=red&color=blue", query
-    end
-  end
-
-  def test_array_params_in_params_with_flat_params
-    with_default_params_encoder(Faraday::FlatParamsEncoder) do
-      create_connection 'http://a.co/page1', :params => {:color => ['red', 'blue']}
-      query = get
-      assert_equal "color=red&color=blue", query
-    end
-  end
-
-  def get(*args)
-    env = @conn.get(*args) do |req|
-      yield(req) if block_given?
-    end
-    env[:url].query
-  end
-end