faraday 0.15.4 → 1.6.0

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

data/spec/faraday/composite_read_io_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+RSpec.describe Faraday::CompositeReadIO do
+  Part = Struct.new(:to_io) do
+    def length
+      to_io.string.length
+    end
+  end
+
+  def part(str)
+    Part.new StringIO.new(str)
+  end
+
+  def composite_io(*parts)
+    Faraday::CompositeReadIO.new(*parts)
+  end
+
+  context 'with empty composite_io' do
+    subject { composite_io }
+
+    it { expect(subject.length).to eq(0) }
+    it { expect(subject.read).to eq('') }
+    it { expect(subject.read(1)).to be_nil }
+  end
+
+  context 'with empty parts' do
+    subject { composite_io(part(''), part('')) }
+
+    it { expect(subject.length).to eq(0) }
+    it { expect(subject.read).to eq('') }
+    it { expect(subject.read(1)).to be_nil }
+  end
+
+  context 'with 2 parts' do
+    subject { composite_io(part('abcd'), part('1234')) }
+
+    it { expect(subject.length).to eq(8) }
+    it { expect(subject.read).to eq('abcd1234') }
+    it 'allows to read in chunks' do
+      expect(subject.read(3)).to eq('abc')
+      expect(subject.read(3)).to eq('d12')
+      expect(subject.read(3)).to eq('34')
+      expect(subject.read(3)).to be_nil
+    end
+    it 'allows to rewind while reading in chunks' do
+      expect(subject.read(3)).to eq('abc')
+      expect(subject.read(3)).to eq('d12')
+      subject.rewind
+      expect(subject.read(3)).to eq('abc')
+      expect(subject.read(5)).to eq('d1234')
+      expect(subject.read(3)).to be_nil
+      subject.rewind
+      expect(subject.read(2)).to eq('ab')
+    end
+  end
+
+  context 'with mix of empty and non-empty parts' do
+    subject { composite_io(part(''), part('abcd'), part(''), part('1234'), part('')) }
+
+    it 'allows to read in chunks' do
+      expect(subject.read(6)).to eq('abcd12')
+      expect(subject.read(6)).to eq('34')
+      expect(subject.read(6)).to be_nil
+    end
+  end
+
+  context 'with utf8 multibyte part' do
+    subject { composite_io(part("\x86"), part('ファイル')) }
+
+    it { expect(subject.read).to eq(String.new("\x86\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB", encoding: 'BINARY')) }
+    it 'allows to read in chunks' do
+      expect(subject.read(3)).to eq(String.new("\x86\xE3\x83", encoding: 'BINARY'))
+      expect(subject.read(3)).to eq(String.new("\x95\xE3\x82", encoding: 'BINARY'))
+      expect(subject.read(8)).to eq(String.new("\xA1\xE3\x82\xA4\xE3\x83\xAB", encoding: 'BINARY'))
+      expect(subject.read(3)).to be_nil
+    end
+  end
+end