plaid 14.11.1 → 14.12.0

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/spec/faraday/adapter/httpclient_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Adapter::HTTPClient do
+  # ruby gem defaults for testing purposes
+  HTTPCLIENT_OPEN = 60
+  HTTPCLIENT_READ = 60
+  HTTPCLIENT_WRITE = 120
+
+  features :request_body_on_query_methods, :reason_phrase_parse, :compression,
+           :trace_method, :local_socket_binding
+
+  it_behaves_like 'an adapter'
+
+  it 'allows to provide adapter specific configs' do
+    adapter = described_class.new do |client|
+      client.keep_alive_timeout = 20
+      client.ssl_config.timeout = 25
+    end
+
+    client = adapter.build_connection(url: URI.parse('https://example.com'))
+    expect(client.keep_alive_timeout).to eq(20)
+    expect(client.ssl_config.timeout).to eq(25)
+  end
+
+  context 'Options' do
+    let(:request) { Faraday::RequestOptions.new }
+    let(:env) { { request: request } }
+    let(:options) { {} }
+    let(:adapter) { Faraday::Adapter::HTTPClient.new }
+    let(:client) { adapter.connection(url: URI.parse('https://example.com')) }
+
+    it 'configures timeout' do
+      assert_default_timeouts!
+
+      request.timeout = 5
+      adapter.configure_timeouts(client, request)
+
+      expect(client.connect_timeout).to eq(5)
+      expect(client.send_timeout).to eq(5)
+      expect(client.receive_timeout).to eq(5)
+    end
+
+    it 'configures open timeout' do
+      assert_default_timeouts!
+
+      request.open_timeout = 1
+      adapter.configure_timeouts(client, request)
+
+      expect(client.connect_timeout).to eq(1)
+      expect(client.send_timeout).to eq(HTTPCLIENT_WRITE)
+      expect(client.receive_timeout).to eq(HTTPCLIENT_READ)
+    end
+
+    it 'configures multiple timeouts' do
+      assert_default_timeouts!
+
+      request.open_timeout = 1
+      request.write_timeout = 10
+      request.read_timeout = 5
+      adapter.configure_timeouts(client, request)
+
+      expect(client.connect_timeout).to eq(1)
+      expect(client.send_timeout).to eq(10)
+      expect(client.receive_timeout).to eq(5)
+    end
+
+    def assert_default_timeouts!
+      expect(client.connect_timeout).to eq(HTTPCLIENT_OPEN)
+      expect(client.send_timeout).to eq(HTTPCLIENT_WRITE)
+      expect(client.receive_timeout).to eq(HTTPCLIENT_READ)
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/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/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/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/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/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/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/spec/faraday/adapter/test_spec.rb

@@ -0,0 +1,377 @@
+# 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
+
+  describe 'for request with non default params encoder' do
+    let(:connection) do
+      Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) do |builder|
+        builder.adapter :test, stubs
+      end
+    end
+    let(:stubs) do
+      described_class::Stubs.new do |stubs|
+        stubs.get('/path?a=x&a=y&a=z') { [200, {}, 'a'] }
+      end
+    end
+
+    context 'when all flat param values are correctly set' do
+      subject(:request) { connection.get('/path?a=x&a=y&a=z') }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    shared_examples 'raise NotFound when params do not satisfy the flat param values' do |params|
+      subject(:request) { connection.get('/path', params) }
+
+      context "with #{params.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x] }
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x y] }
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x z y] } # NOTE: The order of the value is also compared.
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { b: %w[x y z] }
+  end
+
+  describe 'strict_mode' do
+    let(:stubs) do
+      described_class::Stubs.new(strict_mode: true) do |stubs|
+        stubs.get('/strict?a=12&b=xy', 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello') { [200, {}, 'a'] }
+        stubs.get('/with_user_agent?a=12&b=xy', authorization: 'Bearer m_ck', 'User-Agent' => 'My Agent') { [200, {}, 'a'] }
+      end
+    end
+
+    context 'when params and headers are exactly set' do
+      subject(:request) { connection.get('/strict', { a: '12', b: 'xy' }, { authorization: 'Bearer m_ck', x_c: 'hello' }) }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    context 'when params and headers are exactly set with a custom user agent' do
+      subject(:request) { connection.get('/with_user_agent', { a: '12', b: 'xy' }, { authorization: 'Bearer m_ck', 'User-Agent' => 'My Agent' }) }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    shared_examples 'raise NotFound when params do not satisfy the strict check' do |params|
+      subject(:request) { connection.get('/strict', params, { 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello' }) }
+
+      context "with #{params.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { b: 'xy' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '123', b: 'xy' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12', b: 'xyz' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12', b: 'xy', c: 'hello' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { additional: 'special', a: '12', b: 'xy', c: 'hello' }
+
+    shared_examples 'raise NotFound when headers do not satisfy the strict check' do |path, headers|
+      subject(:request) { connection.get(path, { a: 12, b: 'xy' }, headers) }
+
+      context "with #{headers.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { 'X-C' => 'hello' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'Hi' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Basic m_ck', 'x-c': 'hello' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', x_special: 'special' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'Unknown' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent', x_special: 'special' }
+
+    context 'when strict_mode is disabled' do
+      before do
+        stubs.strict_mode = false
+      end
+
+      shared_examples 'does not raise NotFound even when params do not satisfy the strict check' do |params|
+        subject(:request) { connection.get('/strict', params, { 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello' }) }
+
+        context "with #{params.inspect}" do
+          it { expect(request.status).to eq 200 }
+        end
+      end
+
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { a: '12', b: 'xy' }
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { a: '12', b: 'xy', c: 'hello' }
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { additional: 'special', a: '12', b: 'xy', c: 'hello' }
+
+      shared_examples 'does not raise NotFound even when headers do not satisfy the strict check' do |path, headers|
+        subject(:request) { connection.get(path, { a: 12, b: 'xy' }, headers) }
+
+        context "with #{headers.inspect}" do
+          it { expect(request.status).to eq 200 }
+        end
+      end
+
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', x_special: 'special' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', user_agent: 'Special Agent' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent', x_special: 'special' }
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/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/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/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/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/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