faraday 1.0.1 → 1.6.0

data/spec/faraday/options/proxy_options_spec.rb

@@ -14,6 +14,13 @@ RSpec.describe Faraday::ProxyOptions do
       expect(options.inspect).to match('#<Faraday::ProxyOptions uri=')
     end
 
+    it 'defaults to http' do
+      options = Faraday::ProxyOptions.from 'example.org'
+      expect(options.port).to eq(80)
+      expect(options.host).to eq('example.org')
+      expect(options.scheme).to eq('http')
+    end
+
     it 'works with nil' do
       options = Faraday::ProxyOptions.from nil
       expect(options).to be_a_kind_of(Faraday::ProxyOptions)

data/spec/faraday/params_encoders/flat_spec.rb

@@ -31,4 +31,12 @@ RSpec.describe Faraday::FlatParamsEncoder do
     params = { a: [] }
     expect(subject.encode(params)).to eq('a=')
   end
+
+  it 'encodes unsorted when asked' do
+    params = { b: false, a: true }
+    expect(subject.encode(params)).to eq('a=true&b=false')
+    Faraday::FlatParamsEncoder.sort_params = false
+    expect(subject.encode(params)).to eq('b=false&a=true')
+    Faraday::FlatParamsEncoder.sort_params = true
+  end
 end

data/spec/faraday/params_encoders/nested_spec.rb

@@ -94,6 +94,14 @@ RSpec.describe Faraday::NestedParamsEncoder do
     expect(subject.encode(params)).to eq('a%5B%5D=true&a%5B%5D=false')
   end
 
+  it 'encodes unsorted when asked' do
+    params = { b: false, a: true }
+    expect(subject.encode(params)).to eq('a=true&b=false')
+    Faraday::NestedParamsEncoder.sort_params = false
+    expect(subject.encode(params)).to eq('b=false&a=true')
+    Faraday::NestedParamsEncoder.sort_params = true
+  end
+
   shared_examples 'a wrong decoding' do
     it do
       expect { subject.decode(query) }.to raise_error(TypeError) do |e|

data/spec/faraday/rack_builder_spec.rb

@@ -193,4 +193,153 @@ RSpec.describe Faraday::RackBuilder do
       end
     end
   end
+
+  context 'when middleware is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:dog_middleware) do
+      Class.new(Faraday::Middleware) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:dog) do
+      subject.handlers.find { |handler| handler == dog_middleware }.build
+    end
+
+    it 'adds a handler to construct middleware with options passed to use' do
+      subject.use dog_middleware, name: 'Rex'
+      expect { dog }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(dog.name).to eq('Rex')
+    end
+  end
+
+  context 'when a request adapter is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:cat_request) do
+      Class.new(Faraday::Middleware) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:cat) do
+      subject.handlers.find { |handler| handler == cat_request }.build
+    end
+
+    it 'adds a handler to construct request adapter with options passed to request' do
+      Faraday::Request.register_middleware cat_request: cat_request
+      subject.request :cat_request, name: 'Felix'
+      expect { cat }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(cat.name).to eq('Felix')
+    end
+  end
+
+  context 'when a response adapter is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:fish_response) do
+      Class.new(Faraday::Response::Middleware) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:fish) do
+      subject.handlers.find { |handler| handler == fish_response }.build
+    end
+
+    it 'adds a handler to construct response adapter with options passed to response' do
+      Faraday::Response.register_middleware fish_response: fish_response
+      subject.response :fish_response, name: 'Bubbles'
+      expect { fish }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(fish.name).to eq('Bubbles')
+    end
+  end
+
+  context 'when a plain adapter is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:rabbit_adapter) do
+      Class.new(Faraday::Adapter) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:rabbit) do
+      subject.adapter.build
+    end
+
+    it 'adds a handler to construct adapter with options passed to adapter' do
+      Faraday::Adapter.register_middleware rabbit_adapter: rabbit_adapter
+      subject.adapter :rabbit_adapter, name: 'Thumper'
+      expect { rabbit }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rabbit.name).to eq('Thumper')
+    end
+  end
+
+  context 'when handlers are directly added or updated' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:rock_handler) do
+      Class.new do
+        attr_accessor :name
+
+        def initialize(_app, name:)
+          @name = name
+        end
+      end
+    end
+    let(:rock) do
+      subject.handlers.find { |handler| handler == rock_handler }.build
+    end
+
+    it 'adds a handler to construct adapter with options passed to insert' do
+      subject.insert 0, rock_handler, name: 'Stony'
+      expect { rock }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rock.name).to eq('Stony')
+    end
+
+    it 'adds a handler with options passed to insert_after' do
+      subject.insert_after 0, rock_handler, name: 'Rocky'
+      expect { rock }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rock.name).to eq('Rocky')
+    end
+
+    it 'adds a handler with options passed to swap' do
+      subject.insert 0, rock_handler, name: 'Flint'
+      subject.swap 0, rock_handler, name: 'Chert'
+      expect { rock }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rock.name).to eq('Chert')
+    end
+  end
 end

data/spec/faraday/request/authorization_spec.rb

@@ -56,7 +56,7 @@ RSpec.describe Faraday::Request::Authorization do
     end
 
     context 'when other values are provided' do
-      let(:auth_config) { ['baz', foo: 42] }
+      let(:auth_config) { ['baz', { foo: 42 }] }
 
       it { expect(response.body).to match(/^Token /) }
       it { expect(response.body).to match(/token="baz"/) }
@@ -78,7 +78,7 @@ RSpec.describe Faraday::Request::Authorization do
     end
 
     context 'when passed a string and a hash' do
-      let(:auth_config) { ['baz', foo: 42] }
+      let(:auth_config) { ['baz', { foo: 42 }] }
 
       it { expect(response.body).to eq('baz foo="42"') }
 

data/spec/faraday/request/multipart_spec.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 RSpec.describe Faraday::Request::Multipart do
+  let(:options) { {} }
   let(:conn) do
     Faraday.new do |b|
-      b.request :multipart
+      b.request :multipart, options
       b.request :url_encoded
       b.adapter :test do |stub|
         stub.post('/echo') do |env|
@@ -54,9 +55,10 @@ RSpec.describe Faraday::Request::Multipart do
       part_bc, body_bc = result.part('b[c]')
       expect(part_bc).to_not be_nil
       expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition']).to eq(
-        'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
-      )
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
+        )
       expect(part_bc.headers['content-type']).to eq('text/x-ruby')
       expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
       expect(body_bc).to eq(File.read(__FILE__))
@@ -135,9 +137,10 @@ RSpec.describe Faraday::Request::Multipart do
       part_bc, body_bc = result.part('b[][c]')
       expect(part_bc).to_not be_nil
       expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition']).to eq(
-        'form-data; name="b[][c]"; filename="multipart_spec.rb"'
-      )
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
+        )
       expect(part_bc.headers['content-type']).to eq('text/x-ruby')
       expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
       expect(body_bc).to eq(File.read(__FILE__))
@@ -177,9 +180,10 @@ RSpec.describe Faraday::Request::Multipart do
       part_bc, body_bc = result.part('b[c]')
       expect(part_bc).to_not be_nil
       expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition']).to eq(
-        'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
-      )
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
+        )
       expect(part_bc.headers['content-type']).to eq('text/x-ruby')
       expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
       expect(body_bc).to eq(File.read(__FILE__))
@@ -258,9 +262,10 @@ RSpec.describe Faraday::Request::Multipart do
       part_bc, body_bc = result.part('b[][c]')
       expect(part_bc).to_not be_nil
       expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition']).to eq(
-        'form-data; name="b[][c]"; filename="multipart_spec.rb"'
-      )
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
+        )
       expect(part_bc.headers['content-type']).to eq('text/x-ruby')
       expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
       expect(body_bc).to eq(File.read(__FILE__))
@@ -271,4 +276,27 @@ RSpec.describe Faraday::Request::Multipart do
       expect(body_bd).to eq('2')
     end
   end
+
+  context 'when passing flat_encode=true option' do
+    let(:options) { { flat_encode: true } }
+    let(:io) { StringIO.new('io-content') }
+    let(:payload) do
+      {
+        a: 1,
+        b: [
+          Faraday::UploadIO.new(io, 'application/pdf'),
+          Faraday::UploadIO.new(io, 'application/pdf')
+        ]
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'encode params using flat encoder' do
+      response = conn.post('/echo', payload)
+
+      expect(response.body).to include('name="b"')
+      expect(response.body).not_to include('name="b[]"')
+    end
+  end
 end

data/spec/faraday/request/retry_spec.rb

@@ -117,7 +117,7 @@ RSpec.describe Faraday::Request::Retry do
       let(:options) { { max: 2, interval: 0.1, interval_randomness: 0.05 } }
       let(:middleware) { Faraday::Request::Retry.new(nil, options) }
 
-      it { expect(middleware.send(:calculate_retry_interval, 2)).to be_between(0.1, 0.15) }
+      it { expect(middleware.send(:calculate_retry_interval, 2)).to be_between(0.1, 0.105) }
     end
   end
 

data/spec/faraday/request_spec.rb

@@ -6,20 +6,31 @@ RSpec.describe Faraday::Request do
                 headers: { 'Mime-Version' => '1.0' },
                 request: { oauth: { consumer_key: 'anonymous' } })
   end
-  let(:method) { :get }
+  let(:http_method) { :get }
   let(:block) { nil }
 
-  subject { conn.build_request(method, &block) }
+  subject { conn.build_request(http_method, &block) }
 
   context 'when nothing particular is configured' do
-    it { expect(subject.method).to eq(:get) }
+    it { expect(subject.http_method).to eq(:get) }
     it { expect(subject.to_env(conn).ssl.verify).to be_falsey }
   end
 
-  context 'when method is post' do
-    let(:method) { :post }
+  context 'when HTTP method is post' do
+    let(:http_method) { :post }
+
+    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{WARNING: `Faraday::Request#method` is deprecated; use `#http_method` instead. It will be removed in or after version 2.0.\n`Faraday::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

data/spec/faraday/response/raise_error_spec.rb

@@ -29,6 +29,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 400')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(400)
+      expect(ex.response_status).to eq(400)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -37,6 +40,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 401')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(401)
+      expect(ex.response_status).to eq(401)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -45,6 +51,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 403')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(403)
+      expect(ex.response_status).to eq(403)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -53,6 +62,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 404')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(404)
+      expect(ex.response_status).to eq(404)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -61,6 +73,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('407 "Proxy Authentication Required"')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(407)
+      expect(ex.response_status).to eq(407)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -69,6 +84,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 409')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(409)
+      expect(ex.response_status).to eq(409)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -77,6 +95,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 422')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(422)
+      expect(ex.response_status).to eq(422)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -85,6 +106,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('http status could not be derived from the server response')
       expect(ex.response[:headers]['X-Reason']).to eq('nil')
       expect(ex.response[:status]).to be_nil
+      expect(ex.response_status).to be_nil
+      expect(ex.response_body).to eq('fail')
+      expect(ex.response_headers['X-Reason']).to eq('nil')
     end
   end
 
@@ -93,6 +117,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 499')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(499)
+      expect(ex.response_status).to eq(499)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -101,6 +128,42 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 500')
       expect(ex.response[:headers]['X-Error']).to eq('bailout')
       expect(ex.response[:status]).to eq(500)
+      expect(ex.response_status).to eq(500)
+      expect(ex.response_body).to eq('fail')
+      expect(ex.response_headers['X-Error']).to eq('bailout')
+    end
+  end
+
+  describe 'request info' do
+    let(:conn) do
+      Faraday.new do |b|
+        b.response :raise_error
+        b.adapter :test do |stub|
+          stub.post('request?full=true', request_body, request_headers) do
+            [400, { 'X-Reason' => 'because' }, 'keep looking']
+          end
+        end
+      end
+    end
+    let(:request_body) { JSON.generate({ 'item' => 'sth' }) }
+    let(:request_headers) { { 'Authorization' => 'Basic 123' } }
+
+    subject(:perform_request) do
+      conn.post 'request' do |req|
+        req.headers['Authorization'] = 'Basic 123'
+        req.params[:full] = true
+        req.body = request_body
+      end
+    end
+
+    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][: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
   end
 end