faraday 2.5.2 → 2.9.2

data/lib/faraday/utils/headers.rb

@@ -62,10 +62,10 @@ module Faraday
         super(key, val)
       end
 
-      def fetch(key, *args, &block)
+      def fetch(key, ...)
         key = KeyMap[key]
         key = @names.fetch(key.downcase, key)
-        super(key, *args, &block)
+        super(key, ...)
       end
 
       def delete(key)
@@ -77,6 +77,12 @@ module Faraday
         super(key)
       end
 
+      def dig(key, *rest)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, *rest)
+      end
+
       def include?(key)
         @names.include? key.downcase
       end
@@ -132,7 +138,12 @@ module Faraday
 
       # Join multiple values with a comma.
       def add_parsed(key, value)
-        self[key] ? self[key] << ', ' << value : self[key] = value
+        if key?(key)
+          self[key] = self[key].to_s
+          self[key] << ', ' << value
+        else
+          self[key] = value
+        end
       end
     end
   end

data/lib/faraday/utils.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
 require 'uri'
 require 'faraday/utils/headers'
 require 'faraday/utils/params_hash'
@@ -26,7 +25,7 @@ module Faraday
       attr_writer :default_space_encoding
     end
 
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
 
     def escape(str)
       str.to_s.gsub(ESCAPE_RE) do |match|
@@ -38,7 +37,7 @@ module Faraday
       CGI.unescape str.to_s
     end
 
-    DEFAULT_SEP = /[&;] */n.freeze
+    DEFAULT_SEP = /[&;] */n
 
     # Adapted from Rack
     def parse_query(query)
@@ -54,7 +53,7 @@ module Faraday
     end
 
     def basic_header_from(login, pass)
-      value = Base64.encode64("#{login}:#{pass}")
+      value = ["#{login}:#{pass}"].pack('m') # Base64 encoding
       value.delete!("\n")
       "Basic #{value}"
     end

data/lib/faraday/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faraday
-  VERSION = '2.5.2'
+  VERSION = '2.9.2'
 end

data/spec/faraday/adapter/test_spec.rb

@@ -410,4 +410,33 @@ RSpec.describe Faraday::Adapter::Test do
       end
     end
   end
+
+  describe 'request timeout' do
+    subject(:request) do
+      connection.get('/sleep') do |req|
+        req.options.timeout = timeout
+      end
+    end
+
+    before do
+      stubs.get('/sleep') do
+        sleep(0.01)
+        [200, {}, '']
+      end
+    end
+
+    context 'when request is within timeout' do
+      let(:timeout) { 1 }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    context 'when request is too slow' do
+      let(:timeout) { 0.001 }
+
+      it 'raises an exception' do
+        expect { request }.to raise_error(Faraday::TimeoutError)
+      end
+    end
+  end
 end

data/spec/faraday/connection_spec.rb

@@ -300,14 +300,29 @@ RSpec.describe Faraday::Connection do
       it 'joins url to base when used relative path' do
         conn = Faraday.new(url: url)
         uri = conn.build_exclusive_url('service:search?limit=400')
-        expect(uri.to_s).to eq('http://service.com/service%3Asearch?limit=400')
+        expect(uri.to_s).to eq('http://service.com/service:search?limit=400')
       end
 
       it 'joins url to base when used with path prefix' do
         conn = Faraday.new(url: url)
         conn.path_prefix = '/api'
         uri = conn.build_exclusive_url('service:search?limit=400')
-        expect(uri.to_s).to eq('http://service.com/api/service%3Asearch?limit=400')
+        expect(uri.to_s).to eq('http://service.com/api/service:search?limit=400')
+      end
+    end
+
+    context 'with a custom `default_uri_parser`' do
+      let(:url) { 'http://httpbingo.org' }
+      let(:parser) { Addressable::URI }
+
+      around do |example|
+        with_default_uri_parser(parser) do
+          example.run
+        end
+      end
+
+      it 'does not raise error' do
+        expect { conn.build_exclusive_url('/nigiri') }.not_to raise_error
       end
     end
   end

data/spec/faraday/error_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Faraday::ClientError do
+RSpec.describe Faraday::Error do
   describe '.initialize' do
     subject { described_class.new(exception, response) }
     let(:response) { nil }
@@ -12,8 +12,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq(exception.message) }
       it { expect(subject.backtrace).to eq(exception.backtrace) }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError wrapped=#<RuntimeError: test>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error wrapped=#<RuntimeError: test>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with response hash' do
@@ -22,8 +24,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(exception) }
       it { expect(subject.message).to eq('the server responded with status 400') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
       it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with string' do
@@ -32,8 +36,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('custom message') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: custom message>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error #<Faraday::Error: custom message>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with anything else #to_s' do
@@ -42,8 +48,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('["error1", "error2"]') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: ["error1", "error2"]>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error #<Faraday::Error: ["error1", "error2"]>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with exception string and response hash' do
@@ -53,8 +61,25 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(response) }
       it { expect(subject.message).to eq('custom message') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
       it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
+    end
+
+    context 'with exception and response object' do
+      let(:exception) { RuntimeError.new('test') }
+      let(:body) { { test: 'test' } }
+      let(:headers) { { 'Content-Type' => 'application/json' } }
+      let(:response) { Faraday::Response.new(status: 400, response_headers: headers, response_body: body) }
+
+      it { expect(subject.wrapped_exception).to eq(exception) }
+      it { expect(subject.response).to eq(response) }
+      it { expect(subject.message).to eq(exception.message) }
+      it { expect(subject.backtrace).to eq(exception.backtrace) }
+      it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to eq(headers) }
+      it { expect(subject.response_body).to eq(body) }
     end
   end
 end

data/spec/faraday/middleware_spec.rb

@@ -33,6 +33,24 @@ RSpec.describe Faraday::Middleware do
     end
   end
 
+  describe '#on_error' do
+    subject do
+      Class.new(described_class) do
+        def on_error(error)
+          # do nothing
+        end
+      end.new(app)
+    end
+
+    it 'is called by #call' do
+      expect(app).to receive(:call).and_raise(Faraday::ConnectionFailed)
+      is_expected.to receive(:call).and_call_original
+      is_expected.to receive(:on_error)
+
+      expect { subject.call(double) }.to raise_error(Faraday::ConnectionFailed)
+    end
+  end
+
   describe '#close' do
     context "with app that doesn't support \#close" do
       it 'should issue warning' do

data/spec/faraday/options/options_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe Faraday::Options do
   SubOptions = Class.new(Faraday::Options.new(:sub_a, :sub_b))
-  class ParentOptions < Faraday::Options.new(:a, :b, :c)
+  ParentOptions = Faraday::Options.new(:a, :b, :c) do
     options c: SubOptions
   end
 

data/spec/faraday/options/proxy_options_spec.rb

@@ -32,6 +32,14 @@ RSpec.describe Faraday::ProxyOptions do
       expect(proxy.user).to be_nil
       expect(proxy.password).to be_nil
     end
+
+    it 'treats empty string as nil' do
+      proxy = nil
+      proxy_string = proxy.to_s # => empty string
+      options = Faraday::ProxyOptions.from proxy_string
+      expect(options).to be_a_kind_of(Faraday::ProxyOptions)
+      expect(options.inspect).to eq('#<Faraday::ProxyOptions (empty)>')
+    end
   end
 
   it 'allows hash access' do

data/spec/faraday/params_encoders/nested_spec.rb

@@ -62,7 +62,8 @@ RSpec.describe Faraday::NestedParamsEncoder do
   it 'encodes rack compat' do
     params   = { a: [{ one: '1', two: '2' }, '3', ''] }
     result   = Faraday::Utils.unescape(Faraday::NestedParamsEncoder.encode(params)).split('&')
-    expected = Rack::Utils.build_nested_query(params).split('&')
+    escaped = Rack::Utils.build_nested_query(params)
+    expected = Rack::Utils.unescape(escaped).split('&')
     expect(result).to match_array(expected)
   end
 

data/spec/faraday/request/authorization_spec.rb

@@ -72,6 +72,41 @@ RSpec.describe Faraday::Request::Authorization do
       include_examples 'does not interfere with existing authentication'
     end
 
+    context 'with an argument' do
+      let(:response) { conn.get('/auth-echo', nil, 'middle' => 'crunchy surprise') }
+
+      context 'when passed a proc' do
+        let(:auth_config) { [proc { |env| "proc #{env.request_headers['middle']}" }] }
+
+        it { expect(response.body).to eq('Bearer proc crunchy surprise') }
+
+        include_examples 'does not interfere with existing authentication'
+      end
+
+      context 'when passed a lambda' do
+        let(:auth_config) { [->(env) { "lambda #{env.request_headers['middle']}" }] }
+
+        it { expect(response.body).to eq('Bearer lambda crunchy surprise') }
+
+        include_examples 'does not interfere with existing authentication'
+      end
+
+      context 'when passed a callable with an argument' do
+        let(:callable) do
+          Class.new do
+            def call(env)
+              "callable #{env.request_headers['middle']}"
+            end
+          end.new
+        end
+        let(:auth_config) { [callable] }
+
+        it { expect(response.body).to eq('Bearer callable crunchy surprise') }
+
+        include_examples 'does not interfere with existing authentication'
+      end
+    end
+
     context 'when passed too many arguments' do
       let(:auth_config) { %w[baz foo] }
 

data/spec/faraday/request/json_spec.rb

@@ -73,6 +73,30 @@ RSpec.describe Faraday::Request::Json do
     end
   end
 
+  context 'true body' do
+    let(:result) { process(true) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('true')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
+  context 'false body' do
+    let(:result) { process(false) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('false')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
   context 'object body with json type' do
     let(:result) { process({ a: 1 }, 'application/json; charset=utf-8') }
 
@@ -108,4 +132,68 @@ RSpec.describe Faraday::Request::Json do
       expect(result_type).to eq('application/xml; charset=utf-8')
     end
   end
+
+  context 'with encoder' do
+    let(:encoder) do
+      double('Encoder').tap do |e|
+        allow(e).to receive(:dump) { |s, opts| JSON.generate(s, opts) }
+      end
+    end
+
+    let(:result) { process(a: 1) }
+
+    context 'when encoder is passed as object' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: encoder }) }
+
+      it 'calls specified JSON encoder\'s dump method' do
+        expect(encoder).to receive(:dump).with({ a: 1 })
+
+        result
+      end
+
+      it 'encodes body' do
+        expect(result_body).to eq('{"a":1}')
+      end
+
+      it 'adds content type' do
+        expect(result_type).to eq('application/json')
+      end
+    end
+
+    context 'when encoder is passed as an object-method pair' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: [encoder, :dump] }) }
+
+      it 'calls specified JSON encoder' do
+        expect(encoder).to receive(:dump).with({ a: 1 })
+
+        result
+      end
+
+      it 'encodes body' do
+        expect(result_body).to eq('{"a":1}')
+      end
+
+      it 'adds content type' do
+        expect(result_type).to eq('application/json')
+      end
+    end
+
+    context 'when encoder is not passed' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }) }
+
+      it 'calls JSON.generate' do
+        expect(JSON).to receive(:generate).with({ a: 1 })
+
+        result
+      end
+
+      it 'encodes body' do
+        expect(result_body).to eq('{"a":1}')
+      end
+
+      it 'adds content type' do
+        expect(result_type).to eq('application/json')
+      end
+    end
+  end
 end

data/spec/faraday/response/json_spec.rb

@@ -114,4 +114,93 @@ RSpec.describe Faraday::Response::Json, type: :response do
       expect(response.body).to eq(result)
     end
   end
+
+  context 'with decoder' do
+    let(:decoder) do
+      double('Decoder').tap do |e|
+        allow(e).to receive(:load) { |s, opts| JSON.parse(s, opts) }
+      end
+    end
+
+    let(:body) { '{"a": 1}' }
+    let(:result) { { a: 1 } }
+
+    context 'when decoder is passed as object' do
+      let(:options) do
+        {
+          parser_options: {
+            decoder: decoder,
+            option: :option_value,
+            symbolize_names: true
+          }
+        }
+      end
+
+      it 'passes relevant options to specified decoder\'s load method' do
+        expect(decoder).to receive(:load)
+          .with(body, { option: :option_value, symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      end
+    end
+
+    context 'when decoder is passed as an object-method pair' do
+      let(:options) do
+        {
+          parser_options: {
+            decoder: [decoder, :load],
+            option: :option_value,
+            symbolize_names: true
+          }
+        }
+      end
+
+      it 'passes relevant options to specified decoder\'s method' do
+        expect(decoder).to receive(:load)
+          .with(body, { option: :option_value, symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      end
+    end
+
+    context 'when decoder is not passed' do
+      let(:options) do
+        {
+          parser_options: {
+            symbolize_names: true
+          }
+        }
+      end
+
+      it 'passes relevant options to JSON parse' do
+        expect(JSON).to receive(:parse)
+          .with(body, { symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      end
+
+      it 'passes relevant options to JSON parse even when nil responds to :load' do
+        original_allow_message_expectations_on_nil = RSpec::Mocks.configuration.allow_message_expectations_on_nil
+        RSpec::Mocks.configuration.allow_message_expectations_on_nil = true
+        allow(nil).to receive(:respond_to?)
+          .with(:load)
+          .and_return(true)
+
+        expect(JSON).to receive(:parse)
+          .with(body, { symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      ensure
+        RSpec::Mocks.configuration.allow_message_expectations_on_nil = original_allow_message_expectations_on_nil
+      end
+    end
+  end
 end

data/spec/faraday/response/logger_spec.rb

@@ -25,6 +25,7 @@ RSpec.describe Faraday::Response::Logger do
         stubs.get('/filtered_headers') { [200, { 'Content-Type' => 'text/html' }, 'headers response'] }
         stubs.get('/filtered_params') { [200, { 'Content-Type' => 'text/html' }, 'params response'] }
         stubs.get('/filtered_url') { [200, { 'Content-Type' => 'text/html' }, 'url response'] }
+        stubs.get('/connection_failed') { raise Faraday::ConnectionFailed, 'Failed to open TCP connection' }
       end
     end
   end
@@ -64,6 +65,15 @@ RSpec.describe Faraday::Response::Logger do
       expect(formatter).to receive(:response).with(an_instance_of(Faraday::Env))
       conn.get '/hello'
     end
+
+    context 'when no route' do
+      it 'delegates logging to the formatter' do
+        expect(formatter).to receive(:request).with(an_instance_of(Faraday::Env))
+        expect(formatter).to receive(:exception).with(an_instance_of(Faraday::Adapter::Test::Stubs::NotFound))
+
+        expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+      end
+    end
   end
 
   context 'with custom formatter' do
@@ -94,6 +104,16 @@ RSpec.describe Faraday::Response::Logger do
     expect(string_io.string).to match('GET http:/hello')
   end
 
+  it 'logs status' do
+    conn.get '/hello', nil, accept: 'text/html'
+    expect(string_io.string).to match('Status 200')
+  end
+
+  it 'does not log error message by default' do
+    expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+    expect(string_io.string).not_to match(%(no stubbed request for get http:/noroute))
+  end
+
   it 'logs request headers by default' do
     conn.get '/hello', nil, accept: 'text/html'
     expect(string_io.string).to match(%(Accept: "text/html))
@@ -188,6 +208,24 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when logging errors' do
+    let(:logger_options) { { errors: true } }
+
+    it 'logs error message' do
+      expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+      expect(string_io.string).to match(%(no stubbed request for get http:/noroute))
+    end
+  end
+
+  context 'when logging headers and errors' do
+    let(:logger_options) { { headers: true, errors: true } }
+
+    it 'logs error message' do
+      expect { conn.get '/connection_failed' }.to raise_error(Faraday::ConnectionFailed)
+      expect(string_io.string).to match(%(Failed to open TCP connection))
+    end
+  end
+
   context 'when using log_level' do
     let(:logger_options) { { bodies: true, log_level: :debug } }
 

data/spec/faraday/response/raise_error_spec.rb

@@ -11,8 +11,10 @@ RSpec.describe Faraday::Response::RaiseError do
         stub.get('forbidden') { [403, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('proxy-error') { [407, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('request-timeout') { [408, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('conflict') { [409, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('unprocessable-entity') { [422, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('too-many-requests') { [429, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('4xx') { [499, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('nil-status') { [nil, { 'X-Reason' => 'nil' }, 'fail'] }
         stub.get('server-error') { [500, { 'X-Error' => 'bailout' }, 'fail'] }
@@ -79,6 +81,17 @@ RSpec.describe Faraday::Response::RaiseError do
     end
   end
 
+  it 'raises Faraday::RequestTimeoutError for 408 responses' do
+    expect { conn.get('request-timeout') }.to raise_error(Faraday::RequestTimeoutError) do |ex|
+      expect(ex.message).to eq('the server responded with status 408')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(408)
+      expect(ex.response_status).to eq(408)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+
   it 'raises Faraday::ConflictError for 409 responses' do
     expect { conn.get('conflict') }.to raise_error(Faraday::ConflictError) do |ex|
       expect(ex.message).to eq('the server responded with status 409')
@@ -101,6 +114,17 @@ RSpec.describe Faraday::Response::RaiseError do
     end
   end
 
+  it 'raises Faraday::TooManyRequestsError for 429 responses' do
+    expect { conn.get('too-many-requests') }.to raise_error(Faraday::TooManyRequestsError) do |ex|
+      expect(ex.message).to eq('the server responded with status 429')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(429)
+      expect(ex.response_status).to eq(429)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+
   it 'raises Faraday::NilStatusError for nil status in response' do
     expect { conn.get('nil-status') }.to raise_error(Faraday::NilStatusError) do |ex|
       expect(ex.message).to eq('http status could not be derived from the server response')
@@ -137,7 +161,7 @@ RSpec.describe Faraday::Response::RaiseError do
   describe 'request info' do
     let(:conn) do
       Faraday.new do |b|
-        b.response :raise_error
+        b.response :raise_error, **middleware_options
         b.adapter :test do |stub|
           stub.post(url, request_body, request_headers) do
             [400, { 'X-Reason' => 'because' }, 'keep looking']
@@ -145,6 +169,7 @@ RSpec.describe Faraday::Response::RaiseError do
         end
       end
     end
+    let(:middleware_options) { {} }
     let(:request_body) { JSON.generate({ 'item' => 'sth' }) }
     let(:request_headers) { { 'Authorization' => 'Basic 123' } }
     let(:url_path) { 'request' }
@@ -168,5 +193,19 @@ RSpec.describe Faraday::Response::RaiseError do
         expect(ex.response[:request][:body]).to eq(request_body)
       end
     end
+
+    context 'when the include_request option is set to false' do
+      let(:middleware_options) { { include_request: false } }
+
+      it 'does not include request info in the exception' do
+        expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+          expect(ex.response.keys).to contain_exactly(
+            :status,
+            :headers,
+            :body
+          )
+        end
+      end
+    end
   end
 end