faraday 0.15.4 → 1.0.1

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/client_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Requires Ruby with rspec and faraday gems.
+# rspec client_spec.rb
+
+require 'faraday'
+require 'json'
+
+# 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
+
+Rspec.describe Client do
+  let(:stubs)  { Faraday::Adapter::Test::Stubs.new }
+  let(:conn)   { Faraday.new { |b| b.adapter(:test, stubs) } }
+  let(:client) { Client.new(conn) }
+
+  it 'parses name' do
+    stubs.get('/ebi') do |env|
+      # optional: you can inspect the Faraday::Env
+      expect(env.url.path).to eq('/ebi')
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+
+    # uncomment to trigger stubs.verify_stubbed_calls failure
+    # stubs.get('/unused') { [404, {}, ''] }
+
+    expect(client.sushi('ebi')).to eq('shrimp')
+    stubs.verify_stubbed_calls
+  end
+
+  it 'handles 404' do
+    stubs.get('/ebi') do
+      [
+        404,
+        { 'Content-Type': 'application/javascript' },
+        '{}'
+      ]
+    end
+    expect(client.sushi('ebi')).to be_nil
+    stubs.verify_stubbed_calls
+  end
+
+  it 'handles exception' do
+    stubs.get('/ebi') do
+      raise Faraday::ConnectionFailed, nil
+    end
+
+    expect { client.sushi('ebi') }.to raise_error(Faraday::ConnectionFailed)
+    stubs.verify_stubbed_calls
+  end
+end

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/adapter/em_http.rb

@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
 module Faraday
   class Adapter
-    # EventMachine adapter is useful for either asynchronous requests
-    # when in EM reactor loop or for making parallel requests in
+    # EventMachine adapter. This adapter is useful for either asynchronous
+    # requests when in an EM reactor loop, or for making parallel requests in
     # synchronous code.
     class EMHttp < Faraday::Adapter
+      # Options is a module containing helpers to convert the Faraday env object
+      # into options hashes for EMHTTP method calls.
       module Options
+        # @return [Hash]
         def connection_config(env)
           options = {}
           configure_proxy(options, env)
@@ -16,10 +21,10 @@ module Faraday
 
         def request_config(env)
           options = {
-            :body => read_body(env),
-            :head => env[:request_headers],
-            # :keepalive => true,
-            # :file => 'path/to/file', # stream data off disk
+            body: read_body(env),
+            head: env[:request_headers]
+            # keepalive: true,
+            # file: 'path/to/file', # stream data off disk
           }
           configure_compression(options, env)
           options
@@ -30,44 +35,52 @@ module Faraday
           body.respond_to?(:read) ? body.read : body
         end
 
+        # Reads out proxy settings from env into options
         def configure_proxy(options, env)
-          if proxy = request_options(env)[:proxy]
-            options[:proxy] = {
-              :host => proxy[:uri].host,
-              :port => proxy[:uri].port,
-              :authorization => [proxy[:user], proxy[:password]]
-            }
-          end
+          proxy = request_options(env)[:proxy]
+          return unless proxy
+
+          options[:proxy] = {
+            host: proxy[:uri].host,
+            port: proxy[:uri].port,
+            authorization: [proxy[:user], proxy[:password]]
+          }
         end
 
+        # Reads out host and port settings from env into options
         def configure_socket(options, env)
-          if bind = request_options(env)[:bind]
-            options[:bind] = {
-              :host => bind[:host],
-              :port => bind[:port]
-            }
-          end
+          bind = request_options(env)[:bind]
+          return unless bind
+
+          options[:bind] = {
+            host: bind[:host],
+            port: bind[:port]
+          }
         end
 
+        # Reads out SSL certificate settings from env into options
         def configure_ssl(options, env)
-          if env[:url].scheme == 'https' && env[:ssl]
-            options[:ssl] = {
-              :cert_chain_file => env[:ssl][:ca_file],
-              :verify_peer => env[:ssl].fetch(:verify, true)
-            }
-          end
+          return unless env[:url].scheme == 'https' && env[:ssl]
+
+          options[:ssl] = {
+            cert_chain_file: env[:ssl][:ca_file],
+            verify_peer: env[:ssl].fetch(:verify, true)
+          }
         end
 
+        # 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
         def configure_compression(options, env)
-          if env[:method] == :get and not options[:head].key? 'accept-encoding'
-            options[:head]['accept-encoding'] = 'gzip, compressed'
-          end
+          return unless (env[:method] == :get) &&
+                        !options[:head].key?('accept-encoding')
+
+          options[:head]['accept-encoding'] = 'gzip, compressed'
         end
 
         def request_options(env)
@@ -81,7 +94,8 @@ module Faraday
 
       self.supports_parallel = true
 
-      def self.setup_parallel_manager(options = nil)
+      # @return [Manager]
+      def self.setup_parallel_manager(_options = nil)
         Manager.new
       end
 
@@ -94,95 +108,114 @@ module Faraday
       def perform_request(env)
         if parallel?(env)
           manager = env[:parallel_manager]
-          manager.add {
-            perform_single_request(env).
-              callback { env[:response].finish(env) }
-          }
-        else
-          unless EventMachine.reactor_running?
-            error = nil
-            # start EM, block until request is completed
-            EventMachine.run do
-              perform_single_request(env).
-                callback { EventMachine.stop }.
-                errback { |client|
-                  error = error_message(client)
-                  EventMachine.stop
-                }
+          manager.add do
+            perform_single_request(env)
+              .callback { env[:response].finish(env) }
+          end
+        elsif EventMachine.reactor_running?
+          # EM is running: instruct upstream that this is an async request
+          env[:parallel_manager] = true
+          perform_single_request(env)
+            .callback { env[:response].finish(env) }
+            .errback do
+              # TODO: no way to communicate the error in async mode
+              raise NotImplementedError
             end
-            raise_error(error) if error
-          else
-            # EM is running: instruct upstream that this is an async request
-            env[:parallel_manager] = true
-            perform_single_request(env).
-              callback { env[:response].finish(env) }.
-              errback {
-                # TODO: no way to communicate the error in async mode
-                raise NotImplementedError
-              }
+        else
+          error = nil
+          # start EM, block until request is completed
+          EventMachine.run do
+            perform_single_request(env)
+              .callback { EventMachine.stop }
+              .errback do |client|
+                error = error_message(client)
+                EventMachine.stop
+              end
           end
+          raise_error(error) if error
         end
-      rescue EventMachine::Connectify::CONNECTError => err
-        if err.message.include?("Proxy Authentication Required")
-          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-        else
-          raise Error::ConnectionFailed, err
+      rescue EventMachine::Connectify::CONNECTError => e
+        if e.message.include?('Proxy Authentication Required')
+          raise Faraday::ConnectionFailed,
+                %(407 "Proxy Authentication Required ")
         end
-      rescue => err
-        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-          raise Faraday::SSLError, err
-        else
-          raise
+
+        raise Faraday::ConnectionFailed, e
+      rescue StandardError => e
+        if defined?(::OpenSSL::SSL::SSLError) && \
+           e.is_a?(::OpenSSL::SSL::SSLError)
+          raise Faraday::SSLError, e
         end
+
+        raise
       end
 
       # TODO: reuse the connection to support pipelining
       def perform_single_request(env)
         req = create_request(env)
-        req.setup_request(env[:method], request_config(env)).callback { |client|
+        req = req.setup_request(env[:method], request_config(env))
+        req.callback do |client|
+          if env[:request].stream_response?
+            warn "Streaming downloads for #{self.class.name} " \
+              'are not yet implemented.'
+            env[:request].on_data.call(
+              client.response,
+              client.response.bytesize
+            )
+          end
           status = client.response_header.status
           reason = client.response_header.http_reason
-          save_response(env, status, client.response, nil, reason) do |resp_headers|
+          save_response(env, status, client.response, nil, reason) do |headers|
             client.response_header.each do |name, value|
-              resp_headers[name.to_sym] = value
+              headers[name.to_sym] = value
             end
           end
-        }
+        end
       end
 
       def create_request(env)
-        EventMachine::HttpRequest.new(env[:url], connection_config(env).merge(@connection_options))
+        EventMachine::HttpRequest.new(
+          env[:url], connection_config(env).merge(@connection_options)
+        )
       end
 
       def error_message(client)
-        client.error or "request failed"
+        client.error || 'request failed'
       end
 
       def raise_error(msg)
-        errklass = Faraday::Error::ClientError
-        if msg == Errno::ETIMEDOUT
-          errklass = Faraday::Error::TimeoutError
-          msg = "request timed out"
+        error_class = Faraday::ClientError
+        if timeout_message?(msg)
+          error_class = Faraday::TimeoutError
+          msg = 'request timed out'
         elsif msg == Errno::ECONNREFUSED
-          errklass = Faraday::Error::ConnectionFailed
-          msg = "connection refused"
-        elsif msg == "connection closed by server"
-          errklass = Faraday::Error::ConnectionFailed
+          error_class = Faraday::ConnectionFailed
+          msg = 'connection refused'
+        elsif msg == 'connection closed by server'
+          error_class = Faraday::ConnectionFailed
         end
-        raise errklass, msg
+        raise error_class, msg
       end
 
+      def timeout_message?(msg)
+        msg == Errno::ETIMEDOUT ||
+          (msg.is_a?(String) && msg.include?('timeout error'))
+      end
+
+      # @return [Boolean]
       def parallel?(env)
         !!env[:parallel_manager]
       end
 
-      # The parallel manager is designed to start an EventMachine loop
+      # This parallel manager is designed to start an EventMachine loop
       # and block until all registered requests have been completed.
       class Manager
+        # @see reset
         def initialize
           reset
         end
 
+        # Re-initializes instance variables
         def reset
           @registered_procs = []
           @num_registered = 0
@@ -191,27 +224,30 @@ module Faraday
           @running = false
         end
 
-        def running?() @running end
+        # @return [Boolean]
+        def running?
+          @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
 
         def run
-          if @num_registered > 0
+          if @num_registered.positive?
             @running = true
             EventMachine.run do
               @registered_procs.each do |proc|
                 perform_request(&proc)
               end
             end
-            if @errors.size > 0
-              raise Faraday::Error::ClientError, @errors.first || "connection failed"
+            unless @errors.empty?
+              raise Faraday::ClientError, @errors.first || 'connection failed'
             end
           end
         ensure
@@ -220,24 +256,31 @@ module Faraday
 
         def perform_request
           client = yield
-          client.callback { @num_succeeded += 1; check_finished }
-          client.errback { @errors << client.error; check_finished }
+          client.callback do
+            @num_succeeded += 1
+            check_finished
+          end
+          client.errback do
+            @errors << client.error
+            check_finished
+          end
         end
 
         def check_finished
-          if @num_succeeded + @errors.size == @num_registered
-            EventMachine.stop
-          end
+          EventMachine.stop if @num_succeeded + @errors.size == @num_registered
         end
       end
     end
   end
 end
 
-begin
-  require 'openssl'
-rescue LoadError
-  warn "Warning: no such file to load -- openssl. Make sure it is installed if you want HTTPS support"
-else
-  require 'faraday/adapter/em_http_ssl_patch'
-end if Faraday::Adapter::EMHttp.loaded?
+if Faraday::Adapter::EMHttp.loaded?
+  begin
+    require 'openssl'
+  rescue LoadError
+    warn 'Warning: no such file to load -- openssl. ' \
+      'Make sure it is installed if you want HTTPS support'
+  else
+    require 'faraday/adapter/em_http_ssl_patch'
+  end
+end

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -1,43 +1,49 @@
+# frozen_string_literal: true
+
 require 'openssl'
 require 'em-http'
 
+# EventMachine patch to make SSL work.
 module EmHttpSslPatch
   def ssl_verify_peer(cert_string)
-    cert = nil
     begin
-      cert = OpenSSL::X509::Certificate.new(cert_string)
+      @last_seen_cert = OpenSSL::X509::Certificate.new(cert_string)
     rescue OpenSSL::X509::CertificateError
       return false
     end
 
-    @last_seen_cert = cert
-
-    if certificate_store.verify(@last_seen_cert)
-      begin
-        certificate_store.add_cert(@last_seen_cert)
-      rescue OpenSSL::X509::StoreError => e
-        raise e unless e.message == 'cert already in hash table'
-      end
-      true
-    else
-      raise OpenSSL::SSL::SSLError.new(%(unable to verify the server certificate for "#{host}"))
+    unless certificate_store.verify(@last_seen_cert)
+      raise OpenSSL::SSL::SSLError,
+            %(unable to verify the server certificate for "#{host}")
+    end
+
+    begin
+      certificate_store.add_cert(@last_seen_cert)
+    rescue OpenSSL::X509::StoreError => e
+      raise e unless e.message == 'cert already in hash table'
     end
+    true
   end
 
   def ssl_handshake_completed
     return true unless verify_peer?
 
-    unless OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
-      raise OpenSSL::SSL::SSLError.new(%(host "#{host}" does not match the server certificate))
-    else
-      true
+    unless verified_cert_identity?
+      raise OpenSSL::SSL::SSLError,
+            %(host "#{host}" does not match the server certificate)
     end
+
+    true
   end
 
   def verify_peer?
     parent.connopts.tls[:verify_peer]
   end
 
+  def verified_cert_identity?
+    OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
+  end
+
   def host
     parent.uri.host
   end
@@ -53,4 +59,4 @@ module EmHttpSslPatch
   end
 end
 
-EventMachine::HttpStubConnection.send(:include, EmHttpSslPatch)
+EventMachine::HttpStubConnection.include(EmHttpSslPatch)

data/lib/faraday/adapter/em_synchrony/parallel_manager.rb

@@ -1,16 +1,21 @@
+# frozen_string_literal: true
+
 module Faraday
   class Adapter
     class EMSynchrony < Faraday::Adapter
+      # A parallel manager for EMSynchrony.
       class ParallelManager
-
-        # Add requests to queue. The `request` argument should be a
-        # `EM::HttpRequest` object.
+        # Add requests to queue.
+        #
+        # @param request [EM::HttpRequest]
+        # @param method [Symbol, String] HTTP method
+        # @param args [Array] the rest of the positional arguments
         def add(request, method, *args, &block)
           queue << {
-            :request => request,
-            :method => method,
-            :args => args,
-            :block => block
+            request: request,
+            method: method,
+            args: args,
+            block: block
           }
         end
 
@@ -19,19 +24,18 @@ module Faraday
         def run
           result = nil
           if !EM.reactor_running?
-            EM.run {
+            EM.run do
               Fiber.new do
                 result = perform
                 EM.stop
               end.resume
-            }
+            end
           else
             result = perform
           end
           result
         end
 
-
         private
 
         # The request queue.
@@ -59,8 +63,7 @@ module Faraday
           # Block fiber until all requests have returned.
           multi.perform
         end
-
-      end # ParallelManager
-    end # EMSynchrony
-  end # Adapter
-end # Faraday
+      end
+    end
+  end
+end