faraday 0.6.0 → 0.8.0

data/test/connection_test.rb

@@ -1,14 +1,26 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'uri'
 
 class TestConnection < Faraday::TestCase
+
+  def with_proxy_env(proxy)
+    old_proxy = ENV['http_proxy']
+    ENV['http_proxy'] = proxy
+    begin
+      yield
+    ensure
+      ENV['http_proxy'] = old_proxy
+    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_parses_nil_port_out_of_given_url
+  def test_initialize_inherits_default_port_out_of_given_url
     conn = Faraday::Connection.new "http://sushi.com"
-    assert_nil conn.port
+    assert_equal 80, conn.port
   end
 
   def test_initialize_parses_scheme_out_of_given_url
@@ -38,48 +50,48 @@ class TestConnection < Faraday::TestCase
 
   def test_initialize_stores_default_params_from_options
     conn = Faraday::Connection.new :params => {:a => 1}
-    assert_equal 1, conn.params['a']
+    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", :params => {'b' => '2'}
-    assert_equal '1', conn.params['a']
-    assert_equal '2', conn.params['b']
+    conn = Faraday::Connection.new "http://sushi.com/fish?a=1"
+    assert_equal({'a' => '1'}, conn.params)
   end
 
-  def test_initialize_stores_default_headers_from_options
-    conn = Faraday::Connection.new :headers => {:a => 1}
-    assert_equal '1', conn.headers['A']
+  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_basic_auth_sets_authorization_header
-    conn = Faraday::Connection.new
-    conn.basic_auth 'Aladdin', 'open sesame'
-    assert_equal 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==', conn.headers['Authorization']
+  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_long_basic_auth_sets_authorization_header_without_new_lines
+  def test_basic_auth_sets_header
     conn = Faraday::Connection.new
-    conn.basic_auth "A" * 255, ""
-    assert_equal "Basic #{'QUFB' * 85}Og==", conn.headers['Authorization']
-  end
+    assert_nil conn.headers['Authorization']
 
-  def test_auto_parses_basic_auth_from_url
-    conn = Faraday::Connection.new :url => "http://aladdin:opensesame@sushi.com/fish"
-    assert_equal 'Basic YWxhZGRpbjpvcGVuc2VzYW1l', conn.headers['Authorization']
+    conn.basic_auth 'Aladdin', 'open sesame'
+    assert auth = conn.headers['Authorization']
+    assert_equal 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==', auth
   end
 
-  def test_token_auth_sets_authorization_header
-    conn = Faraday::Connection.new
-    conn.token_auth 'abcdef'
-    assert_equal 'Token token="abcdef"', conn.headers['Authorization']
+  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_with_options_sets_authorization_header
+  def test_token_auth_sets_header
     conn = Faraday::Connection.new
+    assert_nil conn.headers['Authorization']
+
     conn.token_auth 'abcdef', :nonce => 'abc'
-    assert_equal 'Token token="abcdef",
-                     nonce="abc"', conn.headers['Authorization']
+    assert auth = conn.headers['Authorization']
+    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
@@ -89,11 +101,11 @@ class TestConnection < Faraday::TestCase
     assert_equal 'sushi.com', uri.host
   end
 
-  def test_build_url_uses_connection_port_as_default_uri_port
+  def test_build_url_overrides_connection_port_for_absolute_urls
     conn = Faraday::Connection.new
     conn.port = 23
     uri = conn.build_url("http://sushi.com")
-    assert_equal 23, uri.port
+    assert_equal 80, uri.port
   end
 
   def test_build_url_uses_connection_scheme_as_default_uri_scheme
@@ -143,39 +155,38 @@ class TestConnection < Faraday::TestCase
     assert_equal '/sake.html', uri.path
   end
 
-  def test_build_url_parses_url_params_into_query
+  def test_build_url_doesnt_add_ending_slash_given_nil_url
     conn = Faraday::Connection.new
-    uri = conn.build_url("http://sushi.com/sake.html", 'a[b]' => '1 + 2')
-    assert_equal "a%5Bb%5D=1%20%2B%202", uri.query
+    conn.url_prefix = "http://sushi.com/nigiri"
+    uri = conn.build_url(nil)
+    assert_equal "/nigiri", uri.path
   end
 
-  def test_build_url_mashes_default_and_given_params_together
-    conn = Faraday::Connection.new 'http://sushi.com/api?token=abc', :params => {'format' => 'json'}
-    url = conn.build_url("nigiri?page=1", :limit => 5)
-    assert_match /limit=5/,      url.query
-    assert_match /page=1/,       url.query
-    assert_match /format=json/,  url.query
-    assert_match /token=abc/,    url.query
+  def test_build_url_doesnt_add_ending_slash_given_empty_url
+    conn = Faraday::Connection.new
+    conn.url_prefix = "http://sushi.com/nigiri"
+    uri = conn.build_url('')
+    assert_equal "/nigiri", uri.path
+  end
+
+  def test_build_url_parses_url_params_into_query
+    conn = Faraday::Connection.new
+    uri = conn.build_url("http://sushi.com/sake.html", 'a[b]' => '1 + 2')
+    assert_equal "a%5Bb%5D=1+%2B+2", uri.query
   end
 
-  def test_build_url_overrides_default_params_with_given_params
-    conn = Faraday::Connection.new 'http://sushi.com/api?token=abc', :params => {'format' => 'json'}
-    url = conn.build_url("nigiri?page=1", :limit => 5, :token => 'def', :format => 'xml')
-    assert_match /limit=5/,        url.query
-    assert_match /page=1/,         url.query
-    assert_match /format=xml/,     url.query
-    assert_match /token=def/,      url.query
-    assert_no_match /format=json/, url.query
-    assert_no_match /token=abc/,   url.query
+  def test_build_url_bracketizes_nested_params_in_query
+    conn = Faraday::Connection.new
+    uri = conn.build_url("http://sushi.com/sake.html", 'a' => {'b' => 'c'})
+    assert_equal "a%5Bb%5D=c", uri.query
   end
 
   def test_build_url_parses_url
     conn = Faraday::Connection.new
     uri = conn.build_url("http://sushi.com/sake.html")
-    assert_equal "http",             uri.scheme
-    assert_equal "sushi.com",        uri.host
+    assert_equal "http",       uri.scheme
+    assert_equal "sushi.com",  uri.host
     assert_equal '/sake.html', uri.path
-    assert_nil uri.port
   end
 
   def test_build_url_parses_url_and_changes_scheme
@@ -185,32 +196,53 @@ class TestConnection < Faraday::TestCase
     assert_equal 'https://sushi.com/sushi/sake.html', uri.to_s
   end
 
-  def test_proxy_accepts_string
+  def test_build_url_handles_uri_instances
     conn = Faraday::Connection.new
-    conn.proxy 'http://proxy.com'
-    assert_equal 'proxy.com', conn.proxy[:uri].host
-    assert_equal [:uri],      conn.proxy.keys
+    uri = conn.build_url(URI('/sake.html'))
+    assert_equal '/sake.html', uri.path
+  end
+
+  def test_proxy_accepts_string
+    with_proxy_env "http://duncan.proxy.com:80" do
+      conn = Faraday::Connection.new
+      conn.proxy 'http://proxy.com'
+      assert_equal 'proxy.com', conn.proxy[:uri].host
+      assert_equal [:uri],      conn.proxy.keys
+    end
   end
 
   def test_proxy_accepts_uri
-    conn = Faraday::Connection.new
-    conn.proxy Addressable::URI.parse('http://proxy.com')
-    assert_equal 'proxy.com', conn.proxy[:uri].host
-    assert_equal [:uri],      conn.proxy.keys
+    with_proxy_env "http://duncan.proxy.com:80" do
+      conn = Faraday::Connection.new
+      conn.proxy URI.parse('http://proxy.com')
+      assert_equal 'proxy.com', conn.proxy[:uri].host
+      assert_equal [:uri],      conn.proxy.keys
+    end
   end
 
   def test_proxy_accepts_hash_with_string_uri
-    conn = Faraday::Connection.new
-    conn.proxy :uri => 'http://proxy.com', :user => 'rick'
-    assert_equal 'proxy.com', conn.proxy[:uri].host
-    assert_equal 'rick',      conn.proxy[:user]
+    with_proxy_env "http://duncan.proxy.com:80" do
+      conn = Faraday::Connection.new
+      conn.proxy :uri => 'http://proxy.com', :user => 'rick'
+      assert_equal 'proxy.com', conn.proxy[:uri].host
+      assert_equal 'rick',      conn.proxy[:user]
+    end
   end
 
   def test_proxy_accepts_hash
-    conn = Faraday::Connection.new
-    conn.proxy :uri => Addressable::URI.parse('http://proxy.com'), :user => 'rick'
-    assert_equal 'proxy.com', conn.proxy[:uri].host
-    assert_equal 'rick',      conn.proxy[:user]
+    with_proxy_env "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[:uri].host
+      assert_equal 'rick',      conn.proxy[:user]
+    end
+  end
+
+  def test_proxy_accepts_http_env
+    with_proxy_env "http://duncan.proxy.com:80" do
+      conn = Faraday::Connection.new
+      assert_equal 'duncan.proxy.com', conn.proxy[:uri].host
+    end
   end
 
   def test_proxy_requires_uri
@@ -222,24 +254,122 @@ class TestConnection < Faraday::TestCase
 
   def test_params_to_query_converts_hash_of_params_to_uri_escaped_query_string
     conn = Faraday::Connection.new
-    class << conn
-      public :build_query
-    end
-    assert_equal "a%5Bb%5D=1%20%2B%202", conn.build_query('a[b]' => '1 + 2')
+    url = conn.build_url('', 'a[b]' => '1 + 2')
+    assert_equal "a%5Bb%5D=1+%2B+2", url.query
   end
 
   def test_dups_connection_object
-    conn = Faraday::Connection.new 'http://sushi.com/foo' do |b|
-      b.adapter :net_http
+    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_url(''), other.build_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_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
+end
+
+class TestRequestParams < Faraday::TestCase
+  def create_connection(*args)
+    @conn = Faraday::Connection.new(*args) do |conn|
+      yield conn if block_given?
+      class << conn
+        undef app
+        def app() lambda { |env| env } end
+      end
     end
-    conn.headers['content-type'] = 'text/plain'
-    conn.params['a'] = '1'
-
-    duped = conn.dup
-    assert_equal conn.build_url(''), duped.build_url('')
-    [:headers, :params, :builder].each do |attr|
-      assert_equal     conn.send(attr),           duped.send(attr)
-      assert_not_equal conn.send(attr).object_id, duped.send(attr).object_id
+  end
+
+  def get(*args)
+    env = @conn.get(*args) do |req|
+      yield req if block_given?
+    end
+    env[:url].query
+  end
+
+  def assert_query_equal(expected, query)
+    assert_equal expected, query.split('&').sort
+  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
 end

data/test/env_test.rb

@@ -2,55 +2,79 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class EnvTest < Faraday::TestCase
   def setup
-    @conn = Faraday.new :url => 'http://sushi.com/api', :headers => {'Mime-Version' => '1.0'}
+    @conn = Faraday.new :url => 'http://sushi.com/api',
+      :headers => {'Mime-Version' => '1.0'},
+      :request => {:oauth => {:consumer_key => 'anonymous'}}
+
     @conn.options[:timeout]      = 3
     @conn.options[:open_timeout] = 5
     @conn.ssl[:verify]           = false
     @conn.proxy 'http://proxy.com'
-    @input = { :body => 'abc' }
-    @env = env_for @conn do |req|
-      req.url 'foo.json', 'a' => 1
-      req['Server'] = 'Faraday'
-      req.body = @input[:body]
-    end
   end
 
   def test_request_create_stores_method
-    assert_equal :get, @env[:method]
+    env = make_env(:get)
+    assert_equal :get, env[:method]
   end
 
-  def test_request_create_stores_addressable_uri
-    assert_equal 'http://sushi.com/api/foo.json?a=1', @env[:url].to_s
+  def test_request_create_stores_uri
+    env = make_env do |req|
+      req.url 'foo.json', 'a' => 1
+    end
+    assert_equal 'http://sushi.com/api/foo.json?a=1', env[:url].to_s
   end
 
   def test_request_create_stores_headers
-    headers = @env[:request_headers]
+    env = make_env do |req|
+      req['Server'] = 'Faraday'
+    end
+    headers = env[:request_headers]
     assert_equal '1.0', headers['mime-version']
     assert_equal 'Faraday', headers['server']
   end
 
   def test_request_create_stores_body
-    assert_equal @input[:body], @env[:body]
+    env = make_env do |req|
+      req.body = 'hi'
+    end
+    assert_equal 'hi', env[:body]
   end
 
-  def test_request_create_stores_timeout_options
-    assert_equal 3, @env[:request][:timeout]
-    assert_equal 5, @env[:request][:open_timeout]
+  def test_global_request_options
+    env = make_env
+    assert_equal 3, env[:request][:timeout]
+    assert_equal 5, env[:request][:open_timeout]
+  end
+
+  def test_per_request_options
+    env = make_env do |req|
+      req.options[:timeout] = 10
+      req.options[:custom] = true
+      req.options[:oauth][:consumer_secret] = 'xyz'
+    end
+    assert_equal 10, env[:request][:timeout]
+    assert_equal 5, env[:request][:open_timeout]
+    assert_equal true, env[:request][:custom]
+
+    oauth_expected = {:consumer_secret => 'xyz', :consumer_key => 'anonymous'}
+    assert_equal oauth_expected, env[:request][:oauth]
   end
 
   def test_request_create_stores_ssl_options
-    assert_equal false, @env[:ssl][:verify]
+    env = make_env
+    assert_equal false, env[:ssl][:verify]
   end
 
   def test_request_create_stores_proxy_options
-    assert_equal 'proxy.com', @env[:request][:proxy][:uri].host
+    env = make_env
+    assert_equal 'proxy.com', env[:request][:proxy][:uri].host
   end
 
-  def env_for(connection)
-    env_setup = Faraday::Request.create do |req|
-      yield req
-    end
-    env_setup.to_env_hash(connection, :get)
+  private
+
+  def make_env(method = :get, connection = @conn, &block)
+    request = connection.build_request(method, &block)
+    request.to_env(connection)
   end
 end
 
@@ -59,6 +83,31 @@ class HeadersTest < Faraday::TestCase
     @headers = Faraday::Utils::Headers.new
   end
 
+  def test_normalizes_different_capitalizations
+    @headers['Content-Type'] = 'application/json'
+    assert_equal ['Content-Type'], @headers.keys
+    assert_equal 'application/json', @headers['Content-Type']
+    assert_equal 'application/json', @headers['CONTENT-TYPE']
+    assert_equal 'application/json', @headers['content-type']
+    assert @headers.include?('content-type')
+
+    @headers['content-type'] = 'application/xml'
+    assert_equal ['Content-Type'], @headers.keys
+    assert_equal 'application/xml', @headers['Content-Type']
+    assert_equal 'application/xml', @headers['CONTENT-TYPE']
+    assert_equal 'application/xml', @headers['content-type']
+  end
+
+  def test_delete_key
+    @headers['Content-Type'] = 'application/json'
+    assert_equal 1, @headers.size
+    assert @headers.include?('content-type')
+    assert_equal 'application/json', @headers.delete('content-type')
+    assert_equal 0, @headers.size
+    assert !@headers.include?('content-type')
+    assert_equal nil, @headers.delete('content-type')
+  end
+
   def test_parse_response_headers_leaves_http_status_line_out
     @headers.parse("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
     assert_equal %w(Content-Type), @headers.keys
@@ -88,45 +137,45 @@ class ResponseTest < Faraday::TestCase
     }
     @response = Faraday::Response.new @env
   end
-  
+
   def test_finished
     assert @response.finished?
   end
-  
+
   def test_error_on_finish
     assert_raises RuntimeError do
       @response.finish({})
     end
   end
-  
+
   def test_not_success
     assert !@response.success?
   end
-  
+
   def test_status
     assert_equal 404, @response.status
   end
-  
+
   def test_body
     assert_equal 'yikes', @response.body
   end
-  
+
   def test_headers
     assert_equal 'text/plain', @response.headers['Content-Type']
     assert_equal 'text/plain', @response['content-type']
   end
-  
+
   def test_apply_request
     @response.apply_request :body => 'a=b', :method => :post
     assert_equal 'yikes', @response.body
     assert_equal :post, @response.env[:method]
   end
-  
+
   def test_marshal
     @response = Faraday::Response.new
     @response.on_complete { }
     @response.finish @env.merge(:custom => 'moo')
-    
+
     loaded = Marshal.load Marshal.dump(@response)
     assert_nil loaded.env[:custom]
     assert_equal %w[body response_headers status], loaded.env.keys.map { |k| k.to_s }.sort

data/test/helper.rb

@@ -1,12 +1,13 @@
-require 'test/unit'
-unless ENV['BUNDLE_GEMFILE']
-  require 'rubygems'
-  require 'bundler'
-  Bundler.setup
+unless ENV['CI']
+  begin
+    require 'simplecov'
+    SimpleCov.start
+  rescue LoadError
+  end
 end
 
-require 'webmock/test_unit'
-WebMock.disable_net_connect!(:allow_localhost => true)
+require 'test/unit'
+require 'stringio'
 
 if ENV['LEFTRIGHT']
   begin
@@ -16,11 +17,7 @@ if ENV['LEFTRIGHT']
   end
 end
 
-unless $LOAD_PATH.include? 'lib'
-  $LOAD_PATH.unshift(File.dirname(__FILE__))
-  $LOAD_PATH.unshift(File.join($LOAD_PATH.first, '..', 'lib'))
-end
-require 'faraday'
+require File.expand_path('../../lib/faraday', __FILE__)
 
 begin
   require 'ruby-debug'
@@ -35,11 +32,24 @@ module Faraday
     LIVE_SERVER = case ENV['LIVE']
       when /^http/ then ENV['LIVE']
       when nil     then nil
-      else 'http://localhost:4567'
+      else 'http://127.0.0.1:4567'
     end
 
     def test_default
       assert true
     end unless defined? ::MiniTest
+
+    def capture_warnings
+      old, $stderr = $stderr, StringIO.new
+      begin
+        yield
+        $stderr.string
+      ensure
+        $stderr = old
+      end
+    end
   end
 end
+
+require 'webmock/test_unit'
+WebMock.disable_net_connect!(:allow => Faraday::TestCase::LIVE_SERVER)