faraday 0.8.0.rc2 → 0.8.0

data/lib/faraday/adapter/patron.rb

@@ -3,17 +3,29 @@ module Faraday
     class Patron < Faraday::Adapter
       dependency 'patron'
 
+      def initialize(app, &block)
+        super(app)
+        @block = block if block_given?
+      end
+
       def call(env)
         super
 
         # TODO: support streaming requests
         env[:body] = env[:body].read if env[:body].respond_to? :read
 
-        session = ::Patron::Session.new
+        session = @session ||= create_session
 
         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
+          end
         end
 
         response = begin
@@ -38,6 +50,16 @@ module Faraday
           actions << :options unless actions.include? :options
         end
       end
+
+      def create_session
+        session = ::Patron::Session.new
+        @block.call(session) if @block
+        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/rack.rb

@@ -0,0 +1,59 @@
+require 'timeout'
+
+module Faraday
+  class Adapter
+    # Sends requests to a Rack app.
+    #
+    # Examples
+    #
+    #   class MyRackApp
+    #     def call(env)
+    #       [200, {'Content-Type' => 'text/html'}, ["hello world"]]
+    #     end
+    #   end
+    #
+    #   Faraday.new do |conn|
+    #     conn.adapter :rack, MyRackApp
+    #   end
+    class Rack < Faraday::Adapter
+      dependency 'rack/test'
+
+      # not prefixed with "HTTP_"
+      SPECIAL_HEADERS = %w[ CONTENT_LENGTH CONTENT_TYPE ]
+
+      def initialize(faraday_app, rack_app)
+        super(faraday_app)
+        mock_session = ::Rack::MockSession.new(rack_app)
+        @session     = ::Rack::Test::Session.new(mock_session)
+      end
+
+      def call(env)
+        super
+        rack_env = {
+          :method => env[:method],
+          :input  => env[:body].respond_to?(:read) ? env[:body].read : env[:body]
+        }
+
+        env[:request_headers].each do |name, value|
+          name = name.upcase.tr('-', '_')
+          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
+          rack_env[name] = value
+        end if env[:request_headers]
+
+        timeout  = env[:request][:timeout] || env[:request][:open_timeout]
+        response = if timeout
+          Timer.timeout(timeout, Faraday::Error::TimeoutError) { execute_request(env, rack_env) }
+        else
+          execute_request(env, rack_env)
+        end
+
+        save_response(env, response.status, response.body, response.headers)
+        @app.call env
+      end
+
+      def execute_request(env, rack_env)
+        @session.request(env[:url].to_s, rack_env)
+      end
+    end
+  end
+end

data/lib/faraday/adapter/typhoeus.rb

@@ -63,10 +63,11 @@ module Faraday
       def configure_ssl(req, env)
         ssl = env[:ssl]
 
-        req.ssl_cert   = ssl[:client_cert_file] if ssl[:client_cert_file]
-        req.ssl_key    = ssl[:client_key_file]  if ssl[:client_key_file]
-        req.ssl_cacert = ssl[:ca_file]          if ssl[:ca_file]
-        req.ssl_capath = ssl[:ca_path]          if ssl[:ca_path]
+        req.ssl_version = ssl[:version]          if ssl[:version]
+        req.ssl_cert    = ssl[:client_cert_file] if ssl[:client_cert_file]
+        req.ssl_key     = ssl[:client_key_file]  if ssl[:client_key_file]
+        req.ssl_cacert  = ssl[:ca_file]          if ssl[:ca_file]
+        req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
       end
 
       def configure_proxy(req, env)

data/lib/faraday/connection.rb

@@ -1,4 +1,3 @@
-require 'base64'
 require 'cgi'
 require 'set'
 require 'forwardable'
@@ -11,8 +10,8 @@ module Faraday
     METHODS = Set.new [:get, :post, :put, :delete, :head, :patch, :options]
     METHODS_WITH_BODIES = Set.new [:post, :put, :patch, :options]
 
-    attr_reader   :params, :headers, :url_prefix, :builder, :options, :ssl, :parallel_manager
-    attr_writer   :default_parallel_manager
+    attr_reader :params, :headers, :url_prefix, :builder, :options, :ssl, :parallel_manager
+    attr_writer :default_parallel_manager
 
     # :url
     # :params
@@ -103,11 +102,18 @@ module Faraday
     end
 
     def basic_auth(login, pass)
-      @builder.insert(0, Faraday::Request::BasicAuthentication, login, pass)
+      headers[Faraday::Request::Authorization::KEY] =
+        Faraday::Request::BasicAuthentication.header(login, pass)
     end
 
-    def token_auth(token, options = {})
-      @builder.insert(0, Faraday::Request::TokenAuthentication, token, options)
+    def token_auth(token, options = nil)
+      headers[Faraday::Request::Authorization::KEY] =
+        Faraday::Request::TokenAuthentication.header(token, options)
+    end
+
+    def authorization(type, token)
+      headers[Faraday::Request::Authorization::KEY] =
+        Faraday::Request::Authorization.header(type, token)
     end
 
     # Internal: Traverse the middleware stack in search of a
@@ -118,9 +124,10 @@ module Faraday
     # Returns a parallel manager or nil if not found.
     def default_parallel_manager
       @default_parallel_manager ||= begin
-        handler = @builder.handlers.find { |h|
+        handler = @builder.handlers.detect do |h|
           h.klass.respond_to?(:supports_parallel?) and h.klass.supports_parallel?
-        }
+        end
+
         if handler then handler.klass.setup_parallel_manager
         elsif block_given? then yield
         end
@@ -155,10 +162,14 @@ module Faraday
     end
 
     # normalize URI() behavior across Ruby versions
-    def self.URI url
-      url.respond_to?(:host) ? url :
-        url.respond_to?(:to_str) ? Kernel.URI(url) :
-          raise(ArgumentError, "bad argument (expected URI object or URI string)")
+    def self.URI(url)
+      if url.respond_to?(:host)
+        url
+      elsif url.respond_to?(:to_str)
+        Kernel.URI(url)
+      else
+        raise ArgumentError, "bad argument (expected URI object or URI string)"
+      end
     end
 
     def_delegators :url_prefix, :scheme, :scheme=, :host, :host=, :port, :port=

data/lib/faraday/request.rb

@@ -15,18 +15,20 @@ module Faraday
 
     autoload_all 'faraday/request',
       :UrlEncoded => 'url_encoded',
-      :Multipart  => 'multipart',
-      :Retry      => 'retry',
-      :Timeout    => 'timeout',
+      :Multipart => 'multipart',
+      :Retry => 'retry',
+      :Timeout => 'timeout',
+      :Authorization => 'authorization',
       :BasicAuthentication => 'basic_authentication',
       :TokenAuthentication => 'token_authentication'
 
     register_middleware \
       :url_encoded => :UrlEncoded,
-      :multipart   => :Multipart,
-      :retry       => :Retry,
-      :basic_auth  => :BasicAuthentication,
-      :token_auth  => :TokenAuthentication
+      :multipart => :Multipart,
+      :retry => :Retry,
+      :authorization => :Authorization,
+      :basic_auth => :BasicAuthentication,
+      :token_auth => :TokenAuthentication
 
     def self.create(request_method)
       new(request_method).tap do |request|

data/lib/faraday/request/authorization.rb

@@ -0,0 +1,40 @@
+module Faraday
+  class Request::Authorization < Faraday::Middleware
+    KEY = "Authorization".freeze
+
+    # Public
+    def self.header(type, token)
+      case token
+      when String, Symbol then "#{type} #{token}"
+      when Hash then build_hash(type.to_s, token)
+      else
+        raise ArgumentError, "Can't build an Authorization #{type} header from #{token.inspect}"
+      end
+    end
+
+    # Internal
+    def self.build_hash(type, hash)
+      offset = KEY.size + type.size + 3
+      comma = ",\n#{' ' * offset}"
+      values = []
+      hash.each do |key, value|
+        values << "#{key}=#{value.to_s.inspect}"
+      end
+      "#{type} #{values * comma}"
+    end
+
+    def initialize(app, type, token)
+      @header_value = self.class.header(type, token)
+      super(app)
+    end
+
+    # Public
+    def call(env)
+      unless env[:request_headers][KEY]
+        env[:request_headers][KEY] = @header_value
+      end
+      @app.call(env)
+    end
+  end
+end
+

data/lib/faraday/request/basic_authentication.rb

@@ -1,17 +1,13 @@
 require 'base64'
 
 module Faraday
-  class Request::BasicAuthentication < Faraday::Middleware
-    def initialize(app, login, pass)
-      super(app)
-      @header_value = "Basic #{Base64.encode64([login, pass].join(':')).gsub("\n", '')}"
-    end
-
-    def call(env)
-      unless env[:request_headers]['Authorization']
-        env[:request_headers]['Authorization'] = @header_value
-      end
-      @app.call(env)
+  class Request::BasicAuthentication < Request::Authorization
+    # Public
+    def self.header(login, pass)
+      value = Base64.encode64([login, pass].join(':'))
+      value.gsub!("\n", '')
+      super(:Basic, value)
     end
   end
 end
+

data/lib/faraday/request/token_authentication.rb

@@ -1,21 +1,15 @@
 module Faraday
-  class Request::TokenAuthentication < Faraday::Middleware
-    def initialize(app, token, options={})
-      super(app)
-
-      values = ["token=#{token.to_s.inspect}"]
-      options.each do |key, value|
-        values << "#{key}=#{value.to_s.inspect}"
-      end
-      comma = ",\n#{' ' * ('Authorization: Token '.size)}"
-      @header_value = "Token #{values * comma}"
+  class Request::TokenAuthentication < Request::Authorization
+    # Public
+    def self.header(token, options = nil)
+      options ||= {}
+      options[:token] = token
+      super :Token, options
     end
 
-    def call(env)
-      unless env[:request_headers]['Authorization']
-        env[:request_headers]['Authorization'] = @header_value
-      end
-      @app.call(env)
+    def initialize(app, token, options = nil)
+      super(app, token, options)
     end
   end
 end
+

data/test/adapters/default_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class DefaultTest < Faraday::TestCase
+
+    def adapter() :default end
+
+    Integration.apply(self, :NonParallel) do
+      # default stack is not configured with Multipart
+      undef :test_POST_sends_files
+    end
+
+  end
+end

data/test/adapters/em_http_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class EMHttpTest < Faraday::TestCase
+
+    def adapter() :em_http end
+
+    Integration.apply(self, :Parallel) do
+      # https://github.com/eventmachine/eventmachine/pull/289
+      undef :test_timeout
+    end
+
+  end
+end

data/test/adapters/em_synchrony_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class EMSynchronyTest < Faraday::TestCase
+
+    def adapter() :em_synchrony end
+
+    Integration.apply(self, :Parallel) do
+      # https://github.com/eventmachine/eventmachine/pull/289
+      undef :test_timeout
+    end
+
+  end unless RUBY_VERSION < '1.9' or (defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE)
+end

data/test/adapters/excon_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class ExconTest < Faraday::TestCase
+
+    def adapter() :excon end
+
+    # https://github.com/geemus/excon/issues/98
+    if defined?(RUBY_ENGINE) and "rbx" == RUBY_ENGINE
+      warn "Warning: Skipping Excon tests on Rubinius"
+    else
+      Integration.apply(self, :NonParallel) do
+        # https://github.com/eventmachine/eventmachine/pull/289
+        undef :test_timeout
+
+        # FIXME: this test fails on Travis with
+        # "Faraday::Error::ClientError: the server responded with status 400"
+        undef :test_POST_sends_files if ENV['CI']
+      end
+    end
+
+  end
+end

data/test/adapters/integration.rb

@@ -0,0 +1,190 @@
+require 'forwardable'
+require File.expand_path("../../helper", __FILE__)
+
+module Adapters
+  # Adapter integration tests. To use, implement two methods:
+  #
+  # `#adapter` required. returns a symbol for the adapter middleware name
+  # `#adapter_options` optional. extra arguments for building an adapter
+  module Integration
+    def self.apply(base, *extras)
+      if Faraday::TestCase::LIVE_SERVER
+        ([:Common] + extras).each {|name| base.send(:include, self.const_get(name)) }
+        yield if block_given?
+      elsif !defined? @warned
+        warn "Warning: Not running integration tests against a live server."
+        warn "Start the server `ruby test/live_server.rb` and set the LIVE=1 env variable."
+        @warned = true
+      end
+    end
+
+    module Parallel
+      def test_in_parallel
+        resp1, resp2 = nil, nil
+
+        connection = create_connection
+        connection.in_parallel do
+          resp1 = connection.get('echo?a=1')
+          resp2 = connection.get('echo?b=2')
+          assert connection.in_parallel?
+          assert_nil resp1.body
+          assert_nil resp2.body
+        end
+        assert !connection.in_parallel?
+        assert_equal 'get ?{"a"=>"1"}', resp1.body
+        assert_equal 'get ?{"b"=>"2"}', resp2.body
+      end
+    end
+
+    module NonParallel
+      def test_no_parallel_support
+        connection = create_connection
+        response = nil
+
+        err = capture_warnings do
+          connection.in_parallel do
+            response = connection.get('echo').body
+          end
+        end
+        assert response
+        assert_match "no parallel-capable adapter on Faraday stack", err
+        assert_match __FILE__, err
+      end
+    end
+
+    module Compression
+      def test_GET_handles_compression
+        res = get('echo_header', :name => 'accept-encoding')
+        assert_match /gzip;.+\bdeflate\b/, res.body
+      end
+    end
+
+    module Common
+      extend Forwardable
+      def_delegators :create_connection, :get, :head, :put, :post, :patch, :delete, :run_request
+
+      def test_GET_retrieves_the_response_body
+        assert_equal 'get', get('echo').body
+      end
+
+      def test_GET_send_url_encoded_params
+        assert_equal %(get ?{"name"=>"zack"}), get('echo', :name => 'zack').body
+      end
+
+      def test_GET_retrieves_the_response_headers
+        response = get('echo')
+        assert_match(/text\/plain/, response.headers['Content-Type'], 'original case fail')
+        assert_match(/text\/plain/, response.headers['content-type'], 'lowercase fail')
+      end
+
+      def test_GET_handles_headers_with_multiple_values
+        assert_equal 'one, two', get('multi').headers['set-cookie']
+      end
+
+      def test_GET_with_body
+        response = get('echo') do |req|
+          req.body = {'bodyrock' => true}
+        end
+        assert_equal %(get {"bodyrock"=>"true"}), response.body
+      end
+
+      def test_GET_sends_user_agent
+        response = get('echo_header', {:name => 'user-agent'}, :user_agent => 'Agent Faraday')
+        assert_equal 'Agent Faraday', response.body
+      end
+
+      def test_POST_send_url_encoded_params
+        assert_equal %(post {"name"=>"zack"}), post('echo', :name => 'zack').body
+      end
+
+      def test_POST_send_url_encoded_nested_params
+        resp = post('echo', 'name' => {'first' => 'zack'})
+        assert_equal %(post {"name"=>{"first"=>"zack"}}), resp.body
+      end
+
+      def test_POST_retrieves_the_response_headers
+        assert_match(/text\/plain/, post('echo').headers['content-type'])
+      end
+
+      def test_POST_sends_files
+        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
+      end
+
+      def test_PUT_send_url_encoded_params
+        assert_equal %(put {"name"=>"zack"}), put('echo', :name => 'zack').body
+      end
+
+      def test_PUT_send_url_encoded_nested_params
+        resp = put('echo', 'name' => {'first' => 'zack'})
+        assert_equal %(put {"name"=>{"first"=>"zack"}}), resp.body
+      end
+
+      def test_PUT_retrieves_the_response_headers
+        assert_match(/text\/plain/, put('echo').headers['content-type'])
+      end
+
+      def test_PATCH_send_url_encoded_params
+        assert_equal %(patch {"name"=>"zack"}), patch('echo', :name => 'zack').body
+      end
+
+      def test_OPTIONS
+        resp = run_request(:options, 'echo', nil, {})
+        assert_equal 'options', resp.body
+      end
+
+      def test_HEAD_retrieves_no_response_body
+        # FIXME: some adapters return empty string, some nil
+        assert_equal '', head('echo').body.to_s
+      end
+
+      def test_HEAD_retrieves_the_response_headers
+        assert_match(/text\/plain/, head('echo').headers['content-type'])
+      end
+
+      def test_DELETE_retrieves_the_response_headers
+        assert_match(/text\/plain/, delete('echo').headers['content-type'])
+      end
+
+      def test_DELETE_retrieves_the_body
+        assert_equal %(delete), delete('echo').body
+      end
+
+      def test_timeout
+        conn = create_connection(:request => {:timeout => 1, :open_timeout => 1})
+        assert_raise Faraday::Error::TimeoutError do
+          conn.get '/slow'
+        end
+      end
+
+      def adapter
+        raise NotImplementedError.new("Need to override #adapter")
+      end
+
+      # extra options to pass when building the adapter
+      def adapter_options
+        []
+      end
+
+      def create_connection(options = {})
+        if adapter == :default
+          builder_block = nil
+        else
+          builder_block = Proc.new do |b|
+            b.request :multipart
+            b.request :url_encoded
+            b.adapter adapter, *adapter_options
+          end
+        end
+
+        Faraday::Connection.new(Faraday::TestCase::LIVE_SERVER, options, &builder_block).tap do |conn|
+          conn.headers['X-Faraday-Adapter'] = adapter.to_s
+          adapter_handler = conn.builder.handlers.last
+          conn.builder.insert_before adapter_handler, Faraday::Response::RaiseError
+        end
+      end
+    end
+  end
+end