faraday 1.10.4 → 2.13.1

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/request/url_encoded_spec.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+require 'stringio'
+
 RSpec.describe Faraday::Request::UrlEncoded do
   let(:conn) do
     Faraday.new do |b|
-      b.request :multipart
       b.request :url_encoded
       b.adapter :test do |stub|
         stub.post('/echo') do |env|
           posted_as = env[:request_headers]['Content-Type']
-          [200, { 'Content-Type' => posted_as }, env[:body]]
+          body = env[:body]
+          if body.respond_to?(:read)
+            body = body.read
+          end
+          [200, { 'Content-Type' => posted_as }, body]
         end
       end
     end
@@ -68,6 +73,11 @@ RSpec.describe Faraday::Request::UrlEncoded do
     expect(response.body).to eq('a%5Bb%5D%5Bc%5D%5B%5D=d')
   end
 
+  it 'works with files' do
+    response = conn.post('/echo', StringIO.new('str=apple'))
+    expect(response.body).to eq('str=apple')
+  end
+
   context 'customising default_space_encoding' do
     around do |example|
       Faraday::Utils.default_space_encoding = '%20'

data/spec/faraday/request_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe Faraday::Request do
   let(:conn) do
-    Faraday.new(url: 'http://sushi.com/api',
+    Faraday.new(url: 'http://httpbingo.org/api',
                 headers: { 'Mime-Version' => '1.0' },
                 request: { oauth: { consumer_key: 'anonymous' } })
   end
@@ -14,6 +14,7 @@ RSpec.describe Faraday::Request do
   context 'when nothing particular is configured' do
     it { expect(subject.http_method).to eq(:get) }
     it { expect(subject.to_env(conn).ssl.verify).to be_falsey }
+    it { expect(subject.to_env(conn).ssl.verify_hostname).to be_falsey }
   end
 
   context 'when HTTP method is post' do
@@ -22,23 +23,12 @@ RSpec.describe Faraday::Request do
     it { expect(subject.http_method).to eq(:post) }
   end
 
-  describe 'deprecate method for HTTP method' do
-    let(:http_method) { :post }
-    let(:expected_warning) do
-      %r{NOTE: Faraday::Request#method is deprecated; use http_method instead\. It will be removed in or after version 2.0 \nFaraday::Request#method called from .+/spec/faraday/request_spec.rb:\d+.}
-    end
-
-    it { expect(subject.method).to eq(:post) }
-
-    it { expect { subject.method }.to output(expected_warning).to_stderr }
-  end
-
   context 'when setting the url on setup with a URI' do
     let(:block) { proc { |req| req.url URI.parse('foo.json?a=1') } }
 
     it { expect(subject.path).to eq(URI.parse('foo.json')) }
     it { expect(subject.params).to eq('a' => '1') }
-    it { expect(subject.to_env(conn).url.to_s).to eq('http://sushi.com/api/foo.json?a=1') }
+    it { expect(subject.to_env(conn).url.to_s).to eq('http://httpbingo.org/api/foo.json?a=1') }
   end
 
   context 'when setting the url on setup with a string path and params' do
@@ -46,7 +36,7 @@ RSpec.describe Faraday::Request do
 
     it { expect(subject.path).to eq('foo.json') }
     it { expect(subject.params).to eq('a' => 1) }
-    it { expect(subject.to_env(conn).url.to_s).to eq('http://sushi.com/api/foo.json?a=1') }
+    it { expect(subject.to_env(conn).url.to_s).to eq('http://httpbingo.org/api/foo.json?a=1') }
   end
 
   context 'when setting the url on setup with a path including params' do
@@ -54,7 +44,7 @@ RSpec.describe Faraday::Request do
 
     it { expect(subject.path).to eq('foo.json') }
     it { expect(subject.params).to eq('a' => '1', 'b' => '2') }
-    it { expect(subject.to_env(conn).url.to_s).to eq('http://sushi.com/api/foo.json?a=1&b=2') }
+    it { expect(subject.to_env(conn).url.to_s).to eq('http://httpbingo.org/api/foo.json?a=1&b=2') }
   end
 
   context 'when setting a header on setup with []= syntax' do

data/spec/faraday/response/json_spec.rb

@@ -76,12 +76,10 @@ RSpec.describe Faraday::Response::Json, type: :response do
   end
 
   it 'includes the response on the ParsingError instance' do
-    begin
-      process('{') { |env| env[:response] = Faraday::Response.new }
-      raise 'Parsing should have failed.'
-    rescue Faraday::ParsingError => e
-      expect(e.response).to be_a(Faraday::Response)
-    end
+    process('{') { |env| env[:response] = Faraday::Response.new }
+    raise 'Parsing should have failed.'
+  rescue Faraday::ParsingError => e
+    expect(e.response).to be_a(Faraday::Response)
   end
 
   context 'HEAD responses' do
@@ -116,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
@@ -54,6 +55,26 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when logger with program name' do
+    let(:logger) { Logger.new(string_io, progname: 'my_best_program') }
+
+    it 'logs with program name' do
+      conn.get '/hello'
+
+      expect(string_io.string).to match('-- my_best_program: request:')
+      expect(string_io.string).to match('-- my_best_program: response:')
+    end
+  end
+
+  context 'when logger without program name' do
+    it 'logs without program name' do
+      conn.get '/hello'
+
+      expect(string_io.string).to match('-- : request:')
+      expect(string_io.string).to match('-- : response:')
+    end
+  end
+
   context 'with default formatter' do
     let(:formatter) { instance_double(Faraday::Logging::Formatter, request: true, response: true, filter: []) }
 
@@ -64,6 +85,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 +124,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))
@@ -149,7 +189,7 @@ RSpec.describe Faraday::Response::Logger do
   context 'when logging request body' do
     let(:logger_options) { { bodies: { request: true } } }
 
-    it 'log only request body' do
+    it 'logs only request body' do
       conn.post '/ohyes', 'name=Tamago', accept: 'text/html'
       expect(string_io.string).to match(%(name=Tamago))
       expect(string_io.string).not_to match(%(pebbles))
@@ -159,7 +199,7 @@ RSpec.describe Faraday::Response::Logger do
   context 'when logging response body' do
     let(:logger_options) { { bodies: { response: true } } }
 
-    it 'log only response body' do
+    it 'logs only response body' do
       conn.post '/ohyes', 'name=Hamachi', accept: 'text/html'
       expect(string_io.string).to match(%(pebbles))
       expect(string_io.string).not_to match(%(name=Hamachi))
@@ -169,13 +209,13 @@ RSpec.describe Faraday::Response::Logger do
   context 'when logging request and response bodies' do
     let(:logger_options) { { bodies: true } }
 
-    it 'log request and response body' do
+    it 'logs request and response body' do
       conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
       expect(string_io.string).to match(%(name=Ebi))
       expect(string_io.string).to match(%(pebbles))
     end
 
-    it 'log response body object' do
+    it 'logs response body object' do
       conn.get '/rubbles', nil, accept: 'text/html'
       expect(string_io.string).to match(%([\"Barney\", \"Betty\", \"Bam Bam\"]\n))
     end
@@ -188,6 +228,39 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when bodies are logged by default' do
+    before do
+      described_class.default_options = { bodies: true }
+    end
+
+    it 'logs response body' do
+      conn.post '/ohai'
+      expect(string_io.string).to match(%(fred))
+    end
+
+    after do
+      described_class.default_options = { bodies: false }
+    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,21 +161,24 @@ 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('request?full=true', request_body, request_headers) do
+          stub.post(url, request_body, request_headers) do
             [400, { 'X-Reason' => 'because' }, 'keep looking']
           end
         end
       end
     end
+    let(:middleware_options) { {} }
     let(:request_body) { JSON.generate({ 'item' => 'sth' }) }
     let(:request_headers) { { 'Authorization' => 'Basic 123' } }
+    let(:url_path) { 'request' }
+    let(:query_params) { 'full=true' }
+    let(:url) { "#{url_path}?#{query_params}" }
 
     subject(:perform_request) do
-      conn.post 'request' do |req|
+      conn.post url do |req|
         req.headers['Authorization'] = 'Basic 123'
-        req.params[:full] = true
         req.body = request_body
       end
     end
@@ -159,11 +186,90 @@ RSpec.describe Faraday::Response::RaiseError do
     it 'returns the request info in the exception' do
       expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
         expect(ex.response[:request][:method]).to eq(:post)
-        expect(ex.response[:request][:url_path]).to eq('/request')
+        expect(ex.response[:request][:url]).to eq(URI("http:/#{url}"))
+        expect(ex.response[:request][:url_path]).to eq("/#{url_path}")
         expect(ex.response[:request][:params]).to eq({ 'full' => 'true' })
         expect(ex.response[:request][:headers]).to match(a_hash_including(request_headers))
         expect(ex.response[:request][:body]).to eq(request_body)
       end
     end
+
+    describe 'DEFAULT_OPTION: include_request' do
+      before(:each) do
+        Faraday::Response::RaiseError.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+
+      after(:all) do
+        Faraday::Response::RaiseError.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+
+      context 'when RaiseError DEFAULT_OPTION (include_request: true) is used' do
+        it 'includes 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,
+              :request
+            )
+          end
+        end
+      end
+
+      context 'when application sets default_options `include_request: false`' do
+        before(:each) do
+          Faraday::Response::RaiseError.default_options = { include_request: false }
+        end
+
+        context 'and when include_request option is omitted' do
+          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
+
+        context 'and when include_request option is explicitly set for instance' do
+          let(:middleware_options) { { include_request: true } }
+
+          it 'includes 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,
+                :request
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe 'allowing certain status codes' do
+    let(:conn) do
+      Faraday.new do |b|
+        b.response :raise_error, allowed_statuses: [404]
+        b.adapter :test do |stub|
+          stub.get('bad-request') { [400, { 'X-Reason' => 'because' }, 'keep looking'] }
+          stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
+        end
+      end
+    end
+
+    it 'raises an error for status codes that are not explicitly allowed' do
+      expect { conn.get('bad-request') }.to raise_error(Faraday::BadRequestError)
+    end
+
+    it 'does not raise an error for allowed status codes' do
+      expect { conn.get('not-found') }.not_to raise_error
+    end
   end
 end

data/spec/faraday/response_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Faraday::Response do
   subject { Faraday::Response.new(env) }
 
   let(:env) do
-    Faraday::Env.from(status: 404, body: 'yikes',
+    Faraday::Env.from(status: 404, body: 'yikes', url: Faraday::Utils.URI('https://lostisland.github.io/faraday'),
                       response_headers: { 'Content-Type' => 'text/plain' })
   end
 
@@ -30,6 +30,7 @@ RSpec.describe Faraday::Response do
     it { expect(hash[:status]).to eq(subject.status) }
     it { expect(hash[:response_headers]).to eq(subject.headers) }
     it { expect(hash[:body]).to eq(subject.body) }
+    it { expect(hash[:url]).to eq(subject.env.url) }
   end
 
   describe 'marshal serialization support' do
@@ -45,6 +46,7 @@ RSpec.describe Faraday::Response do
     it { expect(loaded.env[:body]).to eq(env[:body]) }
     it { expect(loaded.env[:response_headers]).to eq(env[:response_headers]) }
     it { expect(loaded.env[:status]).to eq(env[:status]) }
+    it { expect(loaded.env[:url]).to eq(env[:url]) }
   end
 
   describe '#on_complete' do