faraday 1.0.0 → 1.10.3

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

@@ -189,8 +189,157 @@ RSpec.describe Faraday::RackBuilder do
 
     it 'raises an error while making a request' do
       expect { conn.get('/') }.to raise_error(RuntimeError) do |err|
-        expect(err.message).to eq('missing dependency for Broken: cannot load such file -- zomg/i_dont/exist')
+        expect(err.message).to match(%r{missing dependency for Broken: .+ -- zomg/i_dont/exist})
       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,11 +78,19 @@ 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"') }
 
       include_examples 'does not interfere with existing authentication'
     end
+
+    context 'when passed a string and a proc' do
+      let(:auth_config) { ['Bearer', -> { 'custom_from_proc' }] }
+
+      it { expect(response.body).to eq('Bearer custom_from_proc') }
+
+      include_examples 'does not interfere with existing authentication'
+    end
   end
 end

data/spec/faraday/request/json_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::Json do
+  let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }) }
+
+  def process(body, content_type = nil)
+    env = { body: body, request_headers: Faraday::Utils::Headers.new }
+    env[:request_headers]['content-type'] = content_type if content_type
+    middleware.call(Faraday::Env.from(env)).env
+  end
+
+  def result_body
+    result[:body]
+  end
+
+  def result_type
+    result[:request_headers]['content-type']
+  end
+
+  context 'no body' do
+    let(:result) { process(nil) }
+
+    it "doesn't change body" do
+      expect(result_body).to be_nil
+    end
+
+    it "doesn't add content type" do
+      expect(result_type).to be_nil
+    end
+  end
+
+  context 'empty body' do
+    let(:result) { process('') }
+
+    it "doesn't change body" do
+      expect(result_body).to be_empty
+    end
+
+    it "doesn't add content type" do
+      expect(result_type).to be_nil
+    end
+  end
+
+  context 'string body' do
+    let(:result) { process('{"a":1}') }
+
+    it "doesn't change 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 'object body' do
+    let(:result) { process(a: 1) }
+
+    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 'empty object body' do
+    let(:result) { process({}) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('{}')
+    end
+  end
+
+  context 'object body with json type' do
+    let(:result) { process({ a: 1 }, 'application/json; charset=utf-8') }
+
+    it 'encodes body' do
+      expect(result_body).to eq('{"a":1}')
+    end
+
+    it "doesn't change content type" do
+      expect(result_type).to eq('application/json; charset=utf-8')
+    end
+  end
+
+  context 'object body with vendor json type' do
+    let(:result) { process({ a: 1 }, 'application/vnd.myapp.v1+json; charset=utf-8') }
+
+    it 'encodes body' do
+      expect(result_body).to eq('{"a":1}')
+    end
+
+    it "doesn't change content type" do
+      expect(result_type).to eq('application/vnd.myapp.v1+json; charset=utf-8')
+    end
+  end
+
+  context 'object body with incompatible type' do
+    let(:result) { process({ a: 1 }, 'application/xml; charset=utf-8') }
+
+    it "doesn't change body" do
+      expect(result_body).to eq(a: 1)
+    end
+
+    it "doesn't change content type" do
+      expect(result_type).to eq('application/xml; charset=utf-8')
+    end
+  end
+end

data/spec/faraday/request/url_encoded_spec.rb

@@ -67,4 +67,17 @@ RSpec.describe Faraday::Request::UrlEncoded do
     response = conn.post('/echo', 'a' => { 'b' => { 'c' => ['d'] } })
     expect(response.body).to eq('a%5Bb%5D%5Bc%5D%5B%5D=d')
   end
+
+  context 'customising default_space_encoding' do
+    around do |example|
+      Faraday::Utils.default_space_encoding = '%20'
+      example.run
+      Faraday::Utils.default_space_encoding = nil
+    end
+
+    it 'uses the custom character to encode spaces' do
+      response = conn.post('/echo', str: 'apple banana')
+      expect(response.body).to eq('str=apple%20banana')
+    end
+  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{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

data/spec/faraday/response/json_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Response::Json, type: :response do
+  let(:options) { {} }
+  let(:headers) { {} }
+  let(:middleware) do
+    described_class.new(lambda { |env|
+      Faraday::Response.new(env)
+    }, **options)
+  end
+
+  def process(body, content_type = 'application/json', options = {})
+    env = {
+      body: body, request: options,
+      request_headers: Faraday::Utils::Headers.new,
+      response_headers: Faraday::Utils::Headers.new(headers)
+    }
+    env[:response_headers]['content-type'] = content_type if content_type
+    yield(env) if block_given?
+    middleware.call(Faraday::Env.from(env))
+  end
+
+  context 'no type matching' do
+    it "doesn't change nil body" do
+      expect(process(nil).body).to be_nil
+    end
+
+    it 'nullifies empty body' do
+      expect(process('').body).to be_nil
+    end
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to be_nil
+    end
+  end
+
+  context 'with preserving raw' do
+    let(:options) { { preserve_raw: true } }
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to eq('{"a":1}')
+    end
+  end
+
+  context 'with default regexp type matching' do
+    it 'parses json body of correct type' do
+      response = process('{"a":1}', 'application/x-json')
+      expect(response.body).to eq('a' => 1)
+    end
+
+    it 'ignores json body of incorrect type' do
+      response = process('{"a":1}', 'text/json-xml')
+      expect(response.body).to eq('{"a":1}')
+    end
+  end
+
+  context 'with array type matching' do
+    let(:options) { { content_type: %w[a/b c/d] } }
+
+    it 'parses json body of correct type' do
+      expect(process('{"a":1}', 'a/b').body).to be_a(Hash)
+      expect(process('{"a":1}', 'c/d').body).to be_a(Hash)
+    end
+
+    it 'ignores json body of incorrect type' do
+      expect(process('{"a":1}', 'a/d').body).not_to be_a(Hash)
+    end
+  end
+
+  it 'chokes on invalid json' do
+    expect { process('{!') }.to raise_error(Faraday::ParsingError)
+  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
+  end
+
+  context 'HEAD responses' do
+    it "nullifies the body if it's only one space" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+
+    it "nullifies the body if it's two spaces" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+  end
+
+  context 'JSON options' do
+    let(:body) { '{"a": 1}' }
+    let(:result) { { a: 1 } }
+    let(:options) do
+      {
+        parser_options: {
+          symbolize_names: true
+        }
+      }
+    end
+
+    it 'passes relevant options to JSON parse' do
+      expect(::JSON).to receive(:parse)
+        .with(body, options[:parser_options])
+        .and_return(result)
+
+      response = process(body)
+      expect(response.body).to eq(result)
+    end
+  end
+end

data/spec/faraday/response/middleware_spec.rb

@@ -26,6 +26,22 @@ RSpec.describe Faraday::Response::Middleware do
     end
   end
 
+  context 'with a custom ResponseMiddleware and private parse' do
+    let(:custom_middleware) do
+      Class.new(Faraday::Response::Middleware) do
+        private
+
+        def parse(body)
+          body.upcase
+        end
+      end
+    end
+
+    it 'parses the response' do
+      expect(conn.get('ok').body).to eq('<BODY></BODY>')
+    end
+  end
+
   context 'with a custom ResponseMiddleware but empty response' do
     let(:custom_middleware) do
       Class.new(Faraday::Response::Middleware) 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

data/spec/spec_helper.rb

@@ -38,6 +38,8 @@ require 'pry'
 
 Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
 
+Faraday::Deprecate.skip = false
+
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest