faraday 2.14.4 → 2.15.1

data/spec/support/integration_helper.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Integration test configuration and helpers
+#
+# This module provides configuration and helpers for integration tests that run
+# against real HTTP services in GitHub Actions service containers.
+#
+# Service URLs are accessed by service name in container jobs (no port mapping needed).
+# See .github/workflows/integration-tests.yml for service configuration.
+
+module Faraday
+  module IntegrationHelpers
+    # Service URLs for GitHub Actions service containers
+    # These are accessed by service name when running in container jobs
+    HTTPBIN_URL = ENV.fetch('HTTPBIN_URL', 'http://httpbin')
+    # Forward proxies (mitmdump); the second one requires Basic credentials
+    PROXY_URL = ENV.fetch('PROXY_URL', 'http://proxy:8080')
+    AUTH_PROXY_URL = ENV.fetch('AUTH_PROXY_URL', 'http://auth-proxy:8080')
+
+    # Create a direct Faraday connection to httpbin (no proxy)
+    #
+    # @param options [Hash] Connection options (merged with defaults)
+    # @yield [builder] Middleware stack configuration
+    # @return [Faraday::Connection]
+    def httpbin_connection(options = {}, &block)
+      Faraday.new(HTTPBIN_URL, options, &block)
+    end
+
+    # Generic helper to create a Faraday connection for integration tests
+    #
+    # @param url [String] Base URL for the connection
+    # @param options [Hash] Connection options
+    # @yield [builder] Middleware stack configuration
+    # @return [Faraday::Connection]
+    def create_integration_connection(url, options = {}, &block)
+      Faraday.new(url, options, &block)
+    end
+  end
+end
+
+# Configure RSpec for integration tests
+RSpec.configure do |config|
+  # Include integration helpers in integration tests
+  config.include Faraday::IntegrationHelpers, type: :integration
+
+  # Tag all integration tests for easy filtering
+  # Run with: bundle exec rspec --tag integration
+  # Skip with: bundle exec rspec --tag ~integration
+  config.define_derived_metadata(file_path: %r{/spec/integration/}) do |metadata|
+    metadata[:type] = :integration
+    metadata[:integration] = true
+  end
+
+  # Integration tests may take longer than unit tests
+  config.around(:each, type: :integration) do |example|
+    # Completely disable WebMock for integration tests
+    # (WebMock can interfere with streaming even when "allowed")
+    WebMock.disable!
+
+    begin
+      # Set a reasonable timeout for integration tests (30 seconds)
+      Timeout.timeout(30) do
+        example.run
+      end
+    ensure
+      # Re-enable WebMock for unit tests
+      WebMock.enable!
+      WebMock.disable_net_connect!(allow_localhost: true)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 2.14.4
+  version: 2.15.1
 platform: ruby
 authors:
 - "@technoweenie"
@@ -20,7 +20,7 @@ dependencies:
         version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -30,7 +30,7 @@ dependencies:
         version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -104,37 +104,13 @@ files:
 - lib/faraday/utils/params_hash.rb
 - lib/faraday/version.rb
 - spec/external_adapters/faraday_specs_setup.rb
-- spec/faraday/adapter/test_spec.rb
-- spec/faraday/adapter_registry_spec.rb
-- spec/faraday/adapter_spec.rb
-- spec/faraday/connection_spec.rb
-- spec/faraday/error_spec.rb
-- spec/faraday/middleware_registry_spec.rb
-- spec/faraday/middleware_spec.rb
-- spec/faraday/options/env_spec.rb
-- spec/faraday/options/options_spec.rb
-- spec/faraday/options/proxy_options_spec.rb
-- spec/faraday/options/request_options_spec.rb
-- spec/faraday/params_encoders/flat_spec.rb
-- spec/faraday/params_encoders/nested_spec.rb
-- spec/faraday/rack_builder_spec.rb
-- spec/faraday/request/authorization_spec.rb
-- spec/faraday/request/instrumentation_spec.rb
-- spec/faraday/request/json_spec.rb
-- spec/faraday/request/url_encoded_spec.rb
-- spec/faraday/request_spec.rb
-- spec/faraday/response/json_spec.rb
-- spec/faraday/response/logger_spec.rb
-- spec/faraday/response/raise_error_spec.rb
-- spec/faraday/response_spec.rb
-- spec/faraday/utils/headers_spec.rb
-- spec/faraday/utils_spec.rb
-- spec/faraday_spec.rb
-- spec/spec_helper.rb
 - spec/support/disabling_stub.rb
 - spec/support/fake_safe_buffer.rb
 - spec/support/faraday_middleware_subclasses.rb
 - spec/support/helper_methods.rb
+- spec/support/integration/test_pki.rb
+- spec/support/integration/tls_server.rb
+- spec/support/integration_helper.rb
 - spec/support/shared_examples/adapter.rb
 - spec/support/shared_examples/params_encoder.rb
 - spec/support/shared_examples/request_method.rb
@@ -144,7 +120,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://lostisland.github.io/faraday
-  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.14.4
+  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.15.1
   source_code_uri: https://github.com/lostisland/faraday
   bug_tracker_uri: https://github.com/lostisland/faraday/issues
   rubygems_mfa_required: 'true'

data/spec/faraday/adapter/test_spec.rb

@@ -1,460 +0,0 @@
-# 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
-
-    describe 'body_match?' do
-      let(:stubs) do
-        described_class::Stubs.new do |stubs|
-          stubs.post('/no_check') { [200, {}, 'ok'] }
-          stubs.post('/with_string', 'abc') { [200, {}, 'ok'] }
-          stubs.post(
-            '/with_proc',
-            ->(request_body) { JSON.parse(request_body, symbolize_names: true) == { x: '!', a: [{ m: [{ a: true }], n: 123 }] } },
-            { content_type: 'application/json' }
-          ) do
-            [200, {}, 'ok']
-          end
-        end
-      end
-
-      context 'when trying without any args for body' do
-        subject(:without_body) { connection.post('/no_check') }
-
-        it { expect(without_body.status).to eq 200 }
-      end
-
-      context 'when trying with string body stubs' do
-        subject(:with_string) { connection.post('/with_string', 'abc') }
-
-        it { expect(with_string.status).to eq 200 }
-      end
-
-      context 'when trying with proc body stubs' do
-        subject(:with_proc) do
-          connection.post('/with_proc', JSON.dump(a: [{ n: 123, m: [{ a: true }] }], x: '!'), { 'Content-Type' => 'application/json' })
-        end
-
-        it { expect(with_proc.status).to eq 200 }
-      end
-    end
-  end
-
-  describe 'request timeout' do
-    subject(:request) do
-      connection.get('/sleep') do |req|
-        req.options.timeout = timeout
-      end
-    end
-
-    before do
-      stubs.get('/sleep') do
-        sleep(0.01)
-        [200, {}, '']
-      end
-    end
-
-    context 'when request is within timeout' do
-      let(:timeout) { 1 }
-
-      it { expect(request.status).to eq 200 }
-    end
-
-    context 'when request is too slow' do
-      let(:timeout) { 0.001 }
-
-      it 'raises an exception' do
-        expect { request }.to raise_error(Faraday::TimeoutError)
-      end
-    end
-  end
-
-  describe '#clear' do
-    it 'removes pending stubs' do
-      stubs.clear
-      expect { connection.get('/hello') }.to raise_error(described_class::Stubs::NotFound)
-    end
-
-    it 'removes already consumed stubs' do
-      expect(connection.get('/hello').body).to eq('hello')
-      stubs.clear
-      expect { connection.get('/hello') }.to raise_error(described_class::Stubs::NotFound)
-    end
-
-    it 'leaves the stubs empty' do
-      stubs.clear
-      expect(stubs).to be_empty
-    end
-  end
-end

data/spec/faraday/adapter_registry_spec.rb

@@ -1,28 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# 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