faraday 1.1.0 → 2.7.4

data/spec/faraday/middleware_spec.rb

@@ -2,23 +2,67 @@
 
 RSpec.describe Faraday::Middleware do
   subject { described_class.new(app) }
+  let(:app) { double }
+
+  describe 'options' do
+    context 'when options are passed to the middleware' do
+      subject { described_class.new(app, options) }
+      let(:options) { { field: 'value' } }
+
+      it 'accepts options when initialized' do
+        expect(subject.options[:field]).to eq('value')
+      end
+    end
+  end
+
+  describe '#on_request' do
+    subject do
+      Class.new(described_class) do
+        def on_request(env)
+          # do nothing
+        end
+      end.new(app)
+    end
+
+    it 'is called by #call' do
+      expect(app).to receive(:call).and_return(app)
+      expect(app).to receive(:on_complete)
+      is_expected.to receive(:call).and_call_original
+      is_expected.to receive(:on_request)
+      subject.call(double)
+    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
-      let(:app) { double }
-
       it 'should issue warning' do
-        expect(subject).to receive(:warn)
+        is_expected.to receive(:warn)
         subject.close
       end
     end
 
     context "with app that supports \#close" do
-      let(:app) { double }
-
       it 'should issue warning' do
         expect(app).to receive(:close)
-        expect(subject).to_not receive(:warn)
+        is_expected.to_not receive(:warn)
         subject.close
       end
     end

data/spec/faraday/options/env_spec.rb

@@ -27,14 +27,20 @@ RSpec.describe Faraday::Env do
     expect(ssl.fetch(:verify, true)).to be_falsey
   end
 
+  it 'handle verify_hostname when fetching' do
+    ssl = Faraday::SSLOptions.new
+    ssl.verify_hostname = true
+    expect(ssl.fetch(:verify_hostname, false)).to be_truthy
+  end
+
   it 'retains custom members' do
     env[:foo] = 'custom 1'
-    env[:bar] = :custom_2
+    env[:bar] = :custom2
     env2 = Faraday::Env.from(env)
     env2[:baz] = 'custom 3'
 
     expect(env2[:foo]).to eq('custom 1')
-    expect(env2[:bar]).to eq(:custom_2)
+    expect(env2[:bar]).to eq(:custom2)
     expect(env[:baz]).to be_nil
   end
 

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/nested_spec.rb

@@ -102,6 +102,14 @@ RSpec.describe Faraday::NestedParamsEncoder do
     Faraday::NestedParamsEncoder.sort_params = true
   end
 
+  it 'encodes arrays indices when asked' do
+    params = { a: [0, 1, 2] }
+    expect(subject.encode(params)).to eq('a%5B%5D=0&a%5B%5D=1&a%5B%5D=2')
+    Faraday::NestedParamsEncoder.array_indices = true
+    expect(subject.encode(params)).to eq('a%5B0%5D=0&a%5B1%5D=1&a%5B2%5D=2')
+    Faraday::NestedParamsEncoder.array_indices = false
+  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

@@ -12,16 +12,16 @@ RSpec.describe Faraday::RackBuilder do
 
   class Apple < Handler
   end
+
   class Orange < Handler
   end
-  class Banana < Handler
-  end
 
-  class Broken < Faraday::Middleware
-    dependency 'zomg/i_dont/exist'
+  class Banana < Handler
   end
 
   subject { conn.builder }
+  before { Faraday.default_adapter = :test }
+  after { Faraday.default_adapter = nil }
 
   context 'with default stack' do
     let(:conn) { Faraday::Connection.new }
@@ -88,13 +88,6 @@ RSpec.describe Faraday::RackBuilder do
 
     it { expect(subject.handlers).to eq([Apple]) }
 
-    it 'allows rebuilding' do
-      subject.build do |builder|
-        builder.use(Orange)
-      end
-      expect(subject.handlers).to eq([Orange])
-    end
-
     it 'allows use' do
       subject.use(Orange)
       expect(subject.handlers).to eq([Apple, Orange])
@@ -117,36 +110,6 @@ RSpec.describe Faraday::RackBuilder do
     end
   end
 
-  context 'with custom registered middleware' do
-    let(:conn) { Faraday::Connection.new {} }
-
-    after { Faraday::Middleware.unregister_middleware(:apple) }
-
-    it 'allows to register with constant' do
-      Faraday::Middleware.register_middleware(apple: Apple)
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with symbol' do
-      Faraday::Middleware.register_middleware(apple: :Apple)
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with string' do
-      Faraday::Middleware.register_middleware(apple: 'Apple')
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with Proc' do
-      Faraday::Middleware.register_middleware(apple: -> { Apple })
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-  end
-
   context 'when having two handlers' do
     let(:conn) { Faraday::Connection.new {} }
 
@@ -176,21 +139,30 @@ RSpec.describe Faraday::RackBuilder do
     end
   end
 
-  context 'when having a handler with broken dependency' do
-    let(:conn) do
-      Faraday::Connection.new do |builder|
-        builder.adapter :test do |stub|
-          stub.get('/') { |_| [200, {}, ''] }
+  context 'when adapter is added with named options' do
+    after { Faraday.default_adapter_options = {} }
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:cat_adapter) do
+      Class.new(Faraday::Adapter) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
         end
       end
     end
 
-    before { subject.use(Broken) }
+    let(:cat) { subject.adapter.build }
 
-    it 'raises an error while making a request' do
-      expect { conn.get('/') }.to raise_error(RuntimeError) do |err|
-        expect(err.message).to match(%r{missing dependency for Broken: .+ -- zomg/i_dont/exist})
-      end
+    it 'adds a handler to construct adapter with named options' do
+      Faraday.default_adapter = cat_adapter
+      Faraday.default_adapter_options = { name: 'Chloe' }
+      expect { cat }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(cat.name).to eq 'Chloe'
     end
   end
 
@@ -220,7 +192,7 @@ RSpec.describe Faraday::RackBuilder do
     end
   end
 
-  context 'when a request adapter is added with named arguments' do
+  context 'when a middleware is added with named arguments' do
     let(:conn) { Faraday::Connection.new {} }
 
     let(:cat_request) do
@@ -247,11 +219,11 @@ RSpec.describe Faraday::RackBuilder do
     end
   end
 
-  context 'when a response adapter is added with named arguments' do
+  context 'when a middleware is added with named arguments' do
     let(:conn) { Faraday::Connection.new {} }
 
     let(:fish_response) do
-      Class.new(Faraday::Response::Middleware) do
+      Class.new(Faraday::Middleware) do
         attr_accessor :name
 
         def initialize(app, name:)

data/spec/faraday/request/authorization_spec.rb

@@ -3,7 +3,7 @@
 RSpec.describe Faraday::Request::Authorization do
   let(:conn) do
     Faraday.new do |b|
-      b.request auth_type, *auth_config
+      b.request :authorization, auth_type, *auth_config
       b.adapter :test do |stub|
         stub.get('/auth-echo') do |env|
           [200, {}, env[:request_headers]['Authorization']]
@@ -14,10 +14,10 @@ RSpec.describe Faraday::Request::Authorization do
 
   shared_examples 'does not interfere with existing authentication' do
     context 'and request already has an authentication header' do
-      let(:response) { conn.get('/auth-echo', nil, authorization: 'Token token="bar"') }
+      let(:response) { conn.get('/auth-echo', nil, authorization: 'OAuth oauth_token') }
 
       it 'does not interfere with existing authorization' do
-        expect(response.body).to eq('Token token="bar"')
+        expect(response.body).to eq('OAuth oauth_token')
       end
     end
   end
@@ -25,7 +25,7 @@ RSpec.describe Faraday::Request::Authorization do
   let(:response) { conn.get('/auth-echo') }
 
   describe 'basic_auth' do
-    let(:auth_type) { :basic_auth }
+    let(:auth_type) { :basic }
 
     context 'when passed correct params' do
       let(:auth_config) { %w[aladdin opensesame] }
@@ -44,43 +44,73 @@ RSpec.describe Faraday::Request::Authorization do
     end
   end
 
-  describe 'token_auth' do
-    let(:auth_type) { :token_auth }
+  describe 'authorization' do
+    let(:auth_type) { :Bearer }
 
-    context 'when passed correct params' do
-      let(:auth_config) { 'quux' }
+    context 'when passed a string' do
+      let(:auth_config) { ['custom'] }
 
-      it { expect(response.body).to eq('Token token="quux"') }
+      it { expect(response.body).to eq('Bearer custom') }
 
       include_examples 'does not interfere with existing authentication'
     end
 
-    context 'when other values are provided' do
-      let(:auth_config) { ['baz', { foo: 42 }] }
+    context 'when passed a proc' do
+      let(:auth_config) { [-> { 'custom_from_proc' }] }
 
-      it { expect(response.body).to match(/^Token /) }
-      it { expect(response.body).to match(/token="baz"/) }
-      it { expect(response.body).to match(/foo="42"/) }
+      it { expect(response.body).to eq('Bearer custom_from_proc') }
 
       include_examples 'does not interfere with existing authentication'
     end
-  end
-
-  describe 'authorization' do
-    let(:auth_type) { :authorization }
 
-    context 'when passed two strings' do
-      let(:auth_config) { ['custom', 'abc def'] }
+    context 'when passed a callable' do
+      let(:callable) { double('Callable Authorizer', call: 'custom_from_callable') }
+      let(:auth_config) { [callable] }
 
-      it { expect(response.body).to eq('custom abc def') }
+      it { expect(response.body).to eq('Bearer custom_from_callable') }
 
       include_examples 'does not interfere with existing authentication'
     end
 
-    context 'when passed a string and a hash' do
-      let(:auth_config) { ['baz', { foo: 42 }] }
+    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] }
 
-      it { expect(response.body).to eq('baz foo="42"') }
+      it { expect { response }.to raise_error(ArgumentError) }
 
       include_examples 'does not interfere with existing authentication'
     end

data/spec/faraday/request/instrumentation_spec.rb

@@ -30,13 +30,11 @@ RSpec.describe Faraday::Request::Instrumentation do
 
   it { expect(options.name).to eq('request.faraday') }
   it 'defaults to ActiveSupport::Notifications' do
-    begin
-      res = options.instrumenter
-    rescue NameError => e
-      expect(e.to_s).to match('ActiveSupport')
-    else
-      expect(res).to eq(ActiveSupport::Notifications)
-    end
+    res = options.instrumenter
+  rescue NameError => e
+    expect(e.to_s).to match('ActiveSupport')
+  else
+    expect(res).to eq(ActiveSupport::Notifications)
   end
 
   it 'instruments with default name' do

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

@@ -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{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
     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