faraday 0.17.1 → 1.1.0

data/spec/faraday/adapter/net_http_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter::NetHttp do
+  features :request_body_on_query_methods, :reason_phrase_parse, :compression, :streaming, :trace_method
+
+  it_behaves_like 'an adapter'
+
+  context 'checking http' do
+    let(:url) { URI('http://example.com') }
+    let(:adapter) { described_class.new }
+    let(:http) { adapter.send(:connection, url: url, request: {}) }
+
+    it { expect(http.port).to eq(80) }
+
+    it 'sets max_retries to 0' do
+      adapter.send(:configure_request, http, {})
+
+      expect(http.max_retries).to eq(0) if http.respond_to?(:max_retries=)
+    end
+
+    it 'supports write_timeout' do
+      adapter.send(:configure_request, http, write_timeout: 10)
+
+      expect(http.write_timeout).to eq(10) if http.respond_to?(:write_timeout=)
+    end
+
+    it 'supports open_timeout' do
+      adapter.send(:configure_request, http, open_timeout: 10)
+
+      expect(http.open_timeout).to eq(10)
+    end
+
+    it 'supports read_timeout' do
+      adapter.send(:configure_request, http, read_timeout: 10)
+
+      expect(http.read_timeout).to eq(10)
+    end
+
+    context 'with https url' do
+      let(:url) { URI('https://example.com') }
+
+      it { expect(http.port).to eq(443) }
+    end
+
+    context 'with http url including port' do
+      let(:url) { URI('https://example.com:1234') }
+
+      it { expect(http.port).to eq(1234) }
+    end
+
+    context 'with custom adapter config' do
+      let(:adapter) do
+        described_class.new do |http|
+          http.continue_timeout = 123
+        end
+      end
+
+      it do
+        adapter.send(:configure_request, http, {})
+        expect(http.continue_timeout).to eq(123)
+      end
+    end
+  end
+end

data/spec/faraday/adapter/patron_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter::Patron, unless: defined?(JRUBY_VERSION) do
+  features :reason_phrase_parse
+
+  it_behaves_like 'an adapter'
+
+  it 'allows to provide adapter specific configs' do
+    conn = Faraday.new do |f|
+      f.adapter :patron do |session|
+        session.max_redirects = 10
+        raise 'Configuration block called'
+      end
+    end
+
+    expect { conn.get('/') }.to raise_error(RuntimeError, 'Configuration block called')
+  end
+end

data/spec/faraday/adapter/rack_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter::Rack do
+  features :request_body_on_query_methods, :trace_method,
+           :skip_response_body_on_head
+
+  it_behaves_like 'an adapter', adapter_options: WebmockRackApp.new
+end

data/spec/faraday/adapter/test_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter::Test do
+  let(:stubs) do
+    described_class::Stubs.new do |stub|
+      stub.get('http://domain.test/hello') do
+        [200, { 'Content-Type' => 'text/html' }, 'domain: hello']
+      end
+
+      stub.get('http://wrong.test/hello') do
+        [200, { 'Content-Type' => 'text/html' }, 'wrong: hello']
+      end
+
+      stub.get('http://wrong.test/bait') do
+        [404, { 'Content-Type' => 'text/html' }]
+      end
+
+      stub.get('/hello') do
+        [200, { 'Content-Type' => 'text/html' }, 'hello']
+      end
+
+      stub.get('/method-echo') do |env|
+        [200, { 'Content-Type' => 'text/html' }, env[:method].to_s]
+      end
+
+      stub.get(%r{\A/resources/\d+(?:\?|\z)}) do
+        [200, { 'Content-Type' => 'text/html' }, 'show']
+      end
+
+      stub.get(%r{\A/resources/(specified)\z}) do |_env, meta|
+        [200, { 'Content-Type' => 'text/html' }, "show #{meta[:match_data][1]}"]
+      end
+    end
+  end
+
+  let(:connection) do
+    Faraday.new do |builder|
+      builder.adapter :test, stubs
+    end
+  end
+
+  let(:response) { connection.get('/hello') }
+
+  context 'with simple path sets status' do
+    subject { response.status }
+
+    it { is_expected.to eq 200 }
+  end
+
+  context 'with simple path sets headers' do
+    subject { response.headers['Content-Type'] }
+
+    it { is_expected.to eq 'text/html' }
+  end
+
+  context 'with simple path sets body' do
+    subject { response.body }
+
+    it { is_expected.to eq 'hello' }
+  end
+
+  context 'with host points to the right stub' do
+    subject { connection.get('http://domain.test/hello').body }
+
+    it { is_expected.to eq 'domain: hello' }
+  end
+
+  describe 'can be called several times' do
+    subject { connection.get('/hello').body }
+
+    it { is_expected.to eq 'hello' }
+  end
+
+  describe 'can handle regular expression path' do
+    subject { connection.get('/resources/1').body }
+
+    it { is_expected.to eq 'show' }
+  end
+
+  describe 'can handle single parameter block' do
+    subject { connection.get('/method-echo').body }
+
+    it { is_expected.to eq 'get' }
+  end
+
+  describe 'can handle regular expression path with captured result' do
+    subject { connection.get('/resources/specified').body }
+
+    it { is_expected.to eq 'show specified' }
+  end
+
+  context 'with get params' do
+    subject { connection.get('/param?a=1').body }
+
+    before do
+      stubs.get('/param?a=1') { [200, {}, 'a'] }
+    end
+
+    it { is_expected.to eq 'a' }
+  end
+
+  describe 'ignoring unspecified get params' do
+    before do
+      stubs.get('/optional?a=1') { [200, {}, 'a'] }
+    end
+
+    context 'with multiple params' do
+      subject { connection.get('/optional?a=1&b=1').body }
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'with single param' do
+      subject { connection.get('/optional?a=1').body }
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'without params' do
+      subject(:request) { connection.get('/optional') }
+
+      it do
+        expect { request }.to raise_error(
+          Faraday::Adapter::Test::Stubs::NotFound
+        )
+      end
+    end
+  end
+
+  context 'with http headers' do
+    before do
+      stubs.get('/yo', 'X-HELLO' => 'hello') { [200, {}, 'a'] }
+      stubs.get('/yo') { [200, {}, 'b'] }
+    end
+
+    context 'with header' do
+      subject do
+        connection.get('/yo') { |env| env.headers['X-HELLO'] = 'hello' }.body
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'without header' do
+      subject do
+        connection.get('/yo').body
+      end
+
+      it { is_expected.to eq 'b' }
+    end
+  end
+
+  describe 'different outcomes for the same request' do
+    def make_request
+      connection.get('/foo')
+    end
+
+    subject(:request) { make_request.body }
+
+    before do
+      stubs.get('/foo') { [200, { 'Content-Type' => 'text/html' }, 'hello'] }
+      stubs.get('/foo') { [200, { 'Content-Type' => 'text/html' }, 'world'] }
+    end
+
+    context 'the first request' do
+      it { is_expected.to eq 'hello' }
+    end
+
+    context 'the second request' do
+      before do
+        make_request
+      end
+
+      it { is_expected.to eq 'world' }
+    end
+  end
+
+  describe 'yielding env to stubs' do
+    subject { connection.get('http://foo.com/foo?a=1').body }
+
+    before do
+      stubs.get '/foo' do |env|
+        expect(env[:url].path).to eq '/foo'
+        expect(env[:url].host).to eq 'foo.com'
+        expect(env[:params]['a']).to eq '1'
+        expect(env[:request_headers]['Accept']).to eq 'text/plain'
+        [200, {}, 'a']
+      end
+
+      connection.headers['Accept'] = 'text/plain'
+    end
+
+    it { is_expected.to eq 'a' }
+  end
+
+  describe 'params parsing' do
+    subject { connection.get('http://foo.com/foo?a[b]=1').body }
+
+    context 'with default encoder' do
+      before do
+        stubs.get '/foo' do |env|
+          expect(env[:params]['a']['b']).to eq '1'
+          [200, {}, 'a']
+        end
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'with nested encoder' do
+      before do
+        stubs.get '/foo' do |env|
+          expect(env[:params]['a']['b']).to eq '1'
+          [200, {}, 'a']
+        end
+
+        connection.options.params_encoder = Faraday::NestedParamsEncoder
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+
+    context 'with flat encoder' do
+      before do
+        stubs.get '/foo' do |env|
+          expect(env[:params]['a[b]']).to eq '1'
+          [200, {}, 'a']
+        end
+
+        connection.options.params_encoder = Faraday::FlatParamsEncoder
+      end
+
+      it { is_expected.to eq 'a' }
+    end
+  end
+
+  describe 'raising an error if no stub was found' do
+    describe 'for request' do
+      subject(:request) { connection.get('/invalid') { [200, {}, []] } }
+
+      it { expect { request }.to raise_error described_class::Stubs::NotFound }
+    end
+
+    describe 'for specified host' do
+      subject(:request) { connection.get('http://domain.test/bait') }
+
+      it { expect { request }.to raise_error described_class::Stubs::NotFound }
+    end
+
+    describe 'for request without specified header' do
+      subject(:request) { connection.get('/yo') }
+
+      before do
+        stubs.get('/yo', 'X-HELLO' => 'hello') { [200, {}, 'a'] }
+      end
+
+      it { expect { request }.to raise_error described_class::Stubs::NotFound }
+    end
+  end
+end

data/spec/faraday/adapter/typhoeus_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter::Typhoeus do
+  features :request_body_on_query_methods, :parallel, :trace_method
+
+  it_behaves_like 'an adapter'
+end

data/spec/faraday/adapter_registry_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::AdapterRegistry do
+  describe '#initialize' do
+    subject(:registry) { described_class.new }
+
+    it { expect { registry.get(:FinFangFoom) }.to raise_error(NameError) }
+    it { expect { registry.get('FinFangFoom') }.to raise_error(NameError) }
+
+    it 'looks up class by string name' do
+      expect(registry.get('Faraday::Connection')).to eq(Faraday::Connection)
+    end
+
+    it 'looks up class by symbol name' do
+      expect(registry.get(:Faraday)).to eq(Faraday)
+    end
+
+    it 'caches lookups with implicit name' do
+      registry.set :symbol
+      expect(registry.get('symbol')).to eq(:symbol)
+    end
+
+    it 'caches lookups with explicit name' do
+      registry.set 'string', :name
+      expect(registry.get(:name)).to eq('string')
+    end
+  end
+end

data/spec/faraday/adapter_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter do
+  let(:adapter) { Faraday::Adapter.new }
+  let(:request) { {} }
+
+  context '#request_timeout' do
+    it 'gets :read timeout' do
+      expect(timeout(:read)).to eq(nil)
+
+      request[:timeout] = 5
+      request[:write_timeout] = 1
+
+      expect(timeout(:read)).to eq(5)
+
+      request[:read_timeout] = 2
+
+      expect(timeout(:read)).to eq(2)
+    end
+
+    it 'gets :open timeout' do
+      expect(timeout(:open)).to eq(nil)
+
+      request[:timeout] = 5
+      request[:write_timeout] = 1
+
+      expect(timeout(:open)).to eq(5)
+
+      request[:open_timeout] = 2
+
+      expect(timeout(:open)).to eq(2)
+    end
+
+    it 'gets :write timeout' do
+      expect(timeout(:write)).to eq(nil)
+
+      request[:timeout] = 5
+      request[:read_timeout] = 1
+
+      expect(timeout(:write)).to eq(5)
+
+      request[:write_timeout] = 2
+
+      expect(timeout(:write)).to eq(2)
+    end
+
+    it 'attempts unknown timeout type' do
+      expect { timeout(:unknown) }.to raise_error(ArgumentError)
+    end
+
+    def timeout(type)
+      adapter.send(:request_timeout, type, request)
+    end
+  end
+end