faraday 1.0.0.pre.rc1 → 1.0.0

data/examples/client_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Requires Ruby with test-unit and faraday gems.
+# ruby client_test.rb
+
+require 'faraday'
+require 'json'
+require 'test/unit'
+
+# Example API client
+class Client
+  def initialize(conn)
+    @conn = conn
+  end
+
+  def sushi(jname)
+    res = @conn.get("/#{jname}")
+    data = JSON.parse(res.body)
+    data['name']
+  end
+end
+
+# Example API client test
+class ClientTest < Test::Unit::TestCase
+  def test_sushi_name
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/ebi') do |env|
+      # optional: you can inspect the Faraday::Env
+      assert_equal '/ebi', env.url.path
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+
+    # uncomment to trigger stubs.verify_stubbed_calls failure
+    # stubs.get('/unused') { [404, {}, ''] }
+
+    cli = client(stubs)
+    assert_equal 'shrimp', cli.sushi('ebi')
+    stubs.verify_stubbed_calls
+  end
+
+  def test_sushi_404
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/ebi') do
+      [
+        404,
+        { 'Content-Type': 'application/javascript' },
+        '{}'
+      ]
+    end
+
+    cli = client(stubs)
+    assert_nil cli.sushi('ebi')
+    stubs.verify_stubbed_calls
+  end
+
+  def test_sushi_exception
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/ebi') do
+      raise Faraday::ConnectionFailed, nil
+    end
+
+    cli = client(stubs)
+    assert_raise Faraday::ConnectionFailed do
+      cli.sushi('ebi')
+    end
+    stubs.verify_stubbed_calls
+  end
+
+  def client(stubs)
+    conn = Faraday.new do |builder|
+      builder.adapter :test, stubs
+    end
+    Client.new(conn)
+  end
+end

data/lib/faraday.rb

@@ -19,8 +19,8 @@ require 'faraday/dependency_loader'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = '1.0.0-rc1'
-  METHODS_WITH_QUERY = %w[get head delete connect trace].freeze
+  VERSION = '1.0.0'
+  METHODS_WITH_QUERY = %w[get head delete trace].freeze
   METHODS_WITH_BODY = %w[post put patch].freeze
 
   class << self
@@ -159,8 +159,8 @@ module Faraday
   end
 
   require_libs 'utils', 'options', 'connection', 'rack_builder', 'parameters',
-               'middleware', 'adapter', 'request', 'response', 'upload_io',
-               'error'
+               'middleware', 'adapter', 'request', 'response', 'error',
+               'file_part', 'param_part'
 
   require_lib 'autoload' unless ENV['FARADAY_NO_AUTOLOAD']
 end

data/lib/faraday/adapter.rb

@@ -46,6 +46,27 @@ module Faraday
       @config_block = block
     end
 
+    # Yields or returns an adapter's configured connection. Depends on
+    # #build_connection being defined on this adapter.
+    #
+    # @param env [Faraday::Env, Hash] The env object for a faraday request.
+    #
+    # @return The return value of the given block, or the HTTP connection object
+    #         if no block is given.
+    def connection(env)
+      conn = build_connection(env)
+      return conn unless block_given?
+
+      yield conn
+    end
+
+    # Close any persistent connections. The adapter should still be usable
+    # after calling close.
+    def close
+      # Possible implementation:
+      #   @app.close if @app.respond_to?(:close)
+    end
+
     def call(env)
       env.clear_body if env.needs_body?
       env.response = Response.new
@@ -65,5 +86,30 @@ module Faraday
       env.response.finish(env) unless env.parallel?
       env.response
     end
+
+    # Fetches either a read, write, or open timeout setting. Defaults to the
+    # :timeout value if a more specific one is not given.
+    #
+    # @param type [Symbol] Describes which timeout setting to get: :read,
+    #                      :write, or :open.
+    # @param options [Hash] Hash containing Symbol keys like :timeout,
+    #                       :read_timeout, :write_timeout, :open_timeout, or
+    #                       :timeout
+    #
+    # @return [Integer, nil] Timeout duration in seconds, or nil if no timeout
+    #                        has been set.
+    def request_timeout(type, options)
+      key = TIMEOUT_KEYS.fetch(type) do
+        msg = "Expected :read, :write, :open. Got #{type.inspect} :("
+        raise ArgumentError, msg
+      end
+      options[key] || options[:timeout]
+    end
+
+    TIMEOUT_KEYS = {
+      read: :read_timeout,
+      open: :open_timeout,
+      write: :write_timeout
+    }.freeze
   end
 end

data/lib/faraday/adapter/em_http.rb

@@ -70,10 +70,9 @@ module Faraday
 
         # Reads out timeout settings from env into options
         def configure_timeout(options, env)
-          timeout, open_timeout = request_options(env)
-                                  .values_at(:timeout, :open_timeout)
-          options[:connect_timeout] = options[:inactivity_timeout] = timeout
-          options[:connect_timeout] = open_timeout if open_timeout
+          req = request_options(env)
+          options[:inactivity_timeout] = request_timeout(:read, req)
+          options[:connect_timeout] = request_timeout(:open, req)
         end
 
         # Reads out compression header settings from env into options
@@ -229,11 +228,11 @@ module Faraday
           @running
         end
 
-        def add
+        def add(&block)
           if running?
             perform_request { yield }
           else
-            @registered_procs << Proc.new
+            @registered_procs << block
           end
           @num_registered += 1
         end

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -59,4 +59,4 @@ module EmHttpSslPatch
   end
 end
 
-EventMachine::HttpStubConnection.send(:include, EmHttpSslPatch)
+EventMachine::HttpStubConnection.include(EmHttpSslPatch)

data/lib/faraday/adapter/excon.rb

@@ -6,22 +6,29 @@ module Faraday
     class Excon < Faraday::Adapter
       dependency 'excon'
 
+      def build_connection(env)
+        opts = opts_from_env(env)
+        ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
+      end
+
       def call(env)
         super
 
-        opts = opts_from_env(env)
-        conn = create_connection(env, opts)
-
-        resp = conn.request(method: env[:method].to_s.upcase,
-                            headers: env[:request_headers],
-                            body: read_body(env))
+        req_opts = {
+          method: env[:method].to_s.upcase,
+          headers: env[:request_headers],
+          body: read_body(env)
+        }
 
         req = env[:request]
         if req&.stream_response?
-          warn "Streaming downloads for #{self.class.name} are not yet " \
-               ' implemented.'
-          req.on_data.call(resp.body, resp.body.bytesize)
+          total = 0
+          req_opts[:response_block] = lambda do |chunk, _remain, _total|
+            req.on_data.call(chunk, total += chunk.size)
+          end
         end
+
+        resp = connection(env) { |http| http.request(req_opts) }
         save_response(env, resp.status.to_i, resp.body, resp.headers,
                       resp.reason_phrase)
 
@@ -36,11 +43,6 @@ module Faraday
         raise Faraday::TimeoutError, e
       end
 
-      # @return [Excon]
-      def create_connection(env, opts)
-        ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
-      end
-
       # TODO: support streaming requests
       def read_body(env)
         env[:body].respond_to?(:read) ? env[:body].read : env[:body]
@@ -90,17 +92,17 @@ module Faraday
       end
 
       def amend_opts_with_timeouts!(opts, req)
-        timeout = req[:timeout]
-        return unless timeout
+        if (sec = request_timeout(:read, req))
+          opts[:read_timeout] = sec
+        end
 
-        opts[:read_timeout] = timeout
-        opts[:connect_timeout] = timeout
-        opts[:write_timeout] = timeout
+        if (sec = request_timeout(:write, req))
+          opts[:write_timeout] = sec
+        end
 
-        open_timeout = req[:open_timeout]
-        return unless open_timeout
+        return unless (sec = request_timeout(:open, req))
 
-        opts[:connect_timeout] = open_timeout
+        opts[:connect_timeout] = sec
       end
 
       def amend_opts_with_proxy_settings!(opts, req)

data/lib/faraday/adapter/httpclient.rb

@@ -6,51 +6,54 @@ module Faraday
     class HTTPClient < Faraday::Adapter
       dependency 'httpclient'
 
-      # @return [HTTPClient]
-      def client
-        @client ||= ::HTTPClient.new
-      end
-
-      def call(env)
-        super
-
-        # enable compression
-        client.transparent_gzip_decompression = true
+      def build_connection(env)
+        @client ||= ::HTTPClient.new.tap do |cli|
+          # enable compression
+          cli.transparent_gzip_decompression = true
+        end
 
         if (req = env[:request])
           if (proxy = req[:proxy])
-            configure_proxy proxy
+            configure_proxy @client, proxy
           end
 
           if (bind = req[:bind])
-            configure_socket bind
+            configure_socket @client, bind
           end
 
-          configure_timeouts req
+          configure_timeouts @client, req
         end
 
         if env[:url].scheme == 'https' && (ssl = env[:ssl])
-          configure_ssl ssl
+          configure_ssl @client, ssl
         end
 
-        configure_client
+        configure_client @client
+
+        @client
+      end
+
+      def call(env)
+        super
 
         # TODO: Don't stream yet.
         # https://github.com/nahi/httpclient/pull/90
         env[:body] = env[:body].read if env[:body].respond_to? :read
 
-        resp = client.request env[:method], env[:url],
+        connection(env) do |http|
+          resp = http.request env[:method], env[:url],
                               body: env[:body],
                               header: env[:request_headers]
 
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(resp.body, resp.body.bytesize)
-        end
-        save_response env, resp.status, resp.body, resp.headers, resp.reason
+          if (req = env[:request]).stream_response?
+            warn "Streaming downloads for #{self.class.name} " \
+              'are not yet implemented.'
+            req.on_data.call(resp.body, resp.body.bytesize)
+          end
+          save_response env, resp.status, resp.body, resp.headers, resp.reason
 
-        @app.call env
+          @app.call env
+        end
       rescue ::HTTPClient::TimeoutError, Errno::ETIMEDOUT
         raise Faraday::TimeoutError, $ERROR_INFO
       rescue ::HTTPClient::BadResponseError => e
@@ -71,7 +74,7 @@ module Faraday
       end
 
       # @param bind [Hash]
-      def configure_socket(bind)
+      def configure_socket(client, bind)
         client.socket_local.host = bind[:host]
         client.socket_local.port = bind[:port]
       end
@@ -79,7 +82,7 @@ module Faraday
       # Configure proxy URI and any user credentials.
       #
       # @param proxy [Hash]
-      def configure_proxy(proxy)
+      def configure_proxy(client, proxy)
         client.proxy = proxy[:uri]
         return unless proxy[:user] && proxy[:password]
 
@@ -87,7 +90,7 @@ module Faraday
       end
 
       # @param ssl [Hash]
-      def configure_ssl(ssl)
+      def configure_ssl(client, ssl)
         ssl_config = client.ssl_config
         ssl_config.verify_mode = ssl_verify_mode(ssl)
         ssl_config.cert_store = ssl_cert_store(ssl)
@@ -100,23 +103,21 @@ module Faraday
       end
 
       # @param req [Hash]
-      def configure_timeouts(req)
-        configure_timeout(req) if req[:timeout]
-        configure_open_timeout(req) if req[:open_timeout]
-      end
+      def configure_timeouts(client, req)
+        if (sec = request_timeout(:open, req))
+          client.connect_timeout = sec
+        end
 
-      def configure_timeout(req)
-        client.connect_timeout   = req[:timeout]
-        client.receive_timeout   = req[:timeout]
-        client.send_timeout      = req[:timeout]
-      end
+        if (sec = request_timeout(:write, req))
+          client.send_timeout = sec
+        end
+
+        return unless (sec = request_timeout(:read, req))
 
-      def configure_open_timeout(req)
-        client.connect_timeout   = req[:open_timeout]
-        client.send_timeout      = req[:open_timeout]
+        client.receive_timeout = sec
       end
 
-      def configure_client
+      def configure_client(client)
         @config_block&.call(client)
       end
 

data/lib/faraday/adapter/net_http.rb

@@ -40,16 +40,32 @@ module Faraday
         super(app, opts, &block)
       end
 
-      def call(env)
-        super
-        with_net_http_connection(env) do |http|
-          if (env[:url].scheme == 'https') && env[:ssl]
-            configure_ssl(http, env[:ssl])
+      def build_connection(env)
+        net_http_connection(env).tap do |http|
+          if http.respond_to?(:use_ssl=)
+            http.use_ssl = env[:url].scheme == 'https'
           end
+          configure_ssl(http, env[:ssl])
           configure_request(http, env[:request])
+        end
+      end
 
+      def net_http_connection(env)
+        klass = if (proxy = env[:request][:proxy])
+                  Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port,
+                                   proxy[:user], proxy[:password])
+                else
+                  Net::HTTP
+                end
+        port = env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
+        klass.new(env[:url].hostname, port)
+      end
+
+      def call(env)
+        super
+        http_response = connection(env) do |http|
           begin
-            http_response = perform_request(http, env)
+            perform_request(http, env)
           rescue *NET_HTTP_EXCEPTIONS => e
             if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
               raise Faraday::SSLError, e
@@ -57,13 +73,13 @@ module Faraday
 
             raise Faraday::ConnectionFailed, e
           end
+        end
 
-          save_response(env, http_response.code.to_i,
-                        http_response.body || '', nil,
-                        http_response.message) do |response_headers|
-            http_response.each_header do |key, value|
-              response_headers[key] = value
-            end
+        save_response(env, http_response.code.to_i,
+                      http_response.body || +'', nil,
+                      http_response.message) do |response_headers|
+          http_response.each_header do |key, value|
+            response_headers[key] = value
           end
         end
 
@@ -101,7 +117,7 @@ module Faraday
               env[:request].on_data.call(chunk, size)
             end
           end
-          env[:request].on_data.call('', 0) unless yielded
+          env[:request].on_data.call(+'', 0) unless yielded
           # Net::HTTP returns something,
           # but it's not meaningful according to the docs.
           http_response.body = nil
@@ -134,23 +150,9 @@ module Faraday
         end
       end
 
-      def with_net_http_connection(env)
-        yield net_http_connection(env)
-      end
-
-      def net_http_connection(env)
-        klass = if (proxy = env[:request][:proxy])
-                  Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port,
-                                   proxy[:user], proxy[:password])
-                else
-                  Net::HTTP
-                end
-        port = env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
-        klass.new(env[:url].hostname, port)
-      end
-
       def configure_ssl(http, ssl)
-        http.use_ssl = true
+        return unless ssl
+
         http.verify_mode = ssl_verify_mode(ssl)
         http.cert_store = ssl_cert_store(ssl)
 
@@ -165,17 +167,19 @@ module Faraday
       end
 
       def configure_request(http, req)
-        if req[:timeout]
-          http.read_timeout = req[:timeout]
-          http.open_timeout = req[:timeout]
-          if http.respond_to?(:write_timeout=)
-            http.write_timeout = req[:timeout]
-          end
+        if (sec = request_timeout(:read, req))
+          http.read_timeout = sec
         end
-        http.open_timeout = req[:open_timeout] if req[:open_timeout]
-        if req[:write_timeout] && http.respond_to?(:write_timeout=)
-          http.write_timeout = req[:write_timeout]
+
+        if (sec = http.respond_to?(:write_timeout=) &&
+                  request_timeout(:write, req))
+          http.write_timeout = sec
+        end
+
+        if (sec = request_timeout(:open, req))
+          http.open_timeout = sec
         end
+
         # Only set if Net::Http supports it, since Ruby 2.5.
         http.max_retries = 0 if http.respond_to?(:max_retries=)