faraday 1.4.1 → 2.14.2

data/spec/faraday/response/logger_spec.rb

@@ -21,10 +21,12 @@ RSpec.describe Faraday::Response::Logger do
         stubs.post('/ohai') { [200, { 'Content-Type' => 'text/html' }, 'fred'] }
         stubs.post('/ohyes') { [200, { 'Content-Type' => 'text/html' }, 'pebbles'] }
         stubs.get('/rubbles') { [200, { 'Content-Type' => 'application/json' }, rubbles] }
+        stubs.get('/8bit') { [200, { 'Content-Type' => 'text/html' }, (+'café!').force_encoding(Encoding::ASCII_8BIT)] }
         stubs.get('/filtered_body') { [200, { 'Content-Type' => 'text/html' }, 'soylent green is people'] }
         stubs.get('/filtered_headers') { [200, { 'Content-Type' => 'text/html' }, 'headers response'] }
         stubs.get('/filtered_params') { [200, { 'Content-Type' => 'text/html' }, 'params response'] }
         stubs.get('/filtered_url') { [200, { 'Content-Type' => 'text/html' }, 'url response'] }
+        stubs.get('/connection_failed') { raise Faraday::ConnectionFailed, 'Failed to open TCP connection' }
       end
     end
   end
@@ -54,6 +56,26 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when logger with program name' do
+    let(:logger) { Logger.new(string_io, progname: 'my_best_program') }
+
+    it 'logs with program name' do
+      conn.get '/hello'
+
+      expect(string_io.string).to match('-- my_best_program: request:')
+      expect(string_io.string).to match('-- my_best_program: response:')
+    end
+  end
+
+  context 'when logger without program name' do
+    it 'logs without program name' do
+      conn.get '/hello'
+
+      expect(string_io.string).to match('-- : request:')
+      expect(string_io.string).to match('-- : response:')
+    end
+  end
+
   context 'with default formatter' do
     let(:formatter) { instance_double(Faraday::Logging::Formatter, request: true, response: true, filter: []) }
 
@@ -64,6 +86,15 @@ RSpec.describe Faraday::Response::Logger do
       expect(formatter).to receive(:response).with(an_instance_of(Faraday::Env))
       conn.get '/hello'
     end
+
+    context 'when no route' do
+      it 'delegates logging to the formatter' do
+        expect(formatter).to receive(:request).with(an_instance_of(Faraday::Env))
+        expect(formatter).to receive(:exception).with(an_instance_of(Faraday::Adapter::Test::Stubs::NotFound))
+
+        expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+      end
+    end
   end
 
   context 'with custom formatter' do
@@ -94,6 +125,16 @@ RSpec.describe Faraday::Response::Logger do
     expect(string_io.string).to match('GET http:/hello')
   end
 
+  it 'logs status' do
+    conn.get '/hello', nil, accept: 'text/html'
+    expect(string_io.string).to match('Status 200')
+  end
+
+  it 'does not log error message by default' do
+    expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+    expect(string_io.string).not_to match(%(no stubbed request for get http:/noroute))
+  end
+
   it 'logs request headers by default' do
     conn.get '/hello', nil, accept: 'text/html'
     expect(string_io.string).to match(%(Accept: "text/html))
@@ -149,7 +190,7 @@ RSpec.describe Faraday::Response::Logger do
   context 'when logging request body' do
     let(:logger_options) { { bodies: { request: true } } }
 
-    it 'log only request body' do
+    it 'logs only request body' do
       conn.post '/ohyes', 'name=Tamago', accept: 'text/html'
       expect(string_io.string).to match(%(name=Tamago))
       expect(string_io.string).not_to match(%(pebbles))
@@ -159,7 +200,7 @@ RSpec.describe Faraday::Response::Logger do
   context 'when logging response body' do
     let(:logger_options) { { bodies: { response: true } } }
 
-    it 'log only response body' do
+    it 'logs only response body' do
       conn.post '/ohyes', 'name=Hamachi', accept: 'text/html'
       expect(string_io.string).to match(%(pebbles))
       expect(string_io.string).not_to match(%(name=Hamachi))
@@ -169,15 +210,15 @@ RSpec.describe Faraday::Response::Logger do
   context 'when logging request and response bodies' do
     let(:logger_options) { { bodies: true } }
 
-    it 'log request and response body' do
+    it 'logs request and response body' do
       conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
       expect(string_io.string).to match(%(name=Ebi))
       expect(string_io.string).to match(%(pebbles))
     end
 
-    it 'log response body object' do
+    it 'logs response body object' do
       conn.get '/rubbles', nil, accept: 'text/html'
-      expect(string_io.string).to match(%([\"Barney\", \"Betty\", \"Bam Bam\"]\n))
+      expect(string_io.string).to match(%(["Barney", "Betty", "Bam Bam"]\n))
     end
 
     it 'logs filter body' do
@@ -188,6 +229,44 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when bodies are logged by default' do
+    before do
+      described_class.default_options = { bodies: true }
+    end
+
+    it 'logs response body' do
+      conn.post '/ohai'
+      expect(string_io.string).to match(%(fred))
+    end
+
+    it 'converts to UTF-8' do
+      conn.get '/8bit'
+      expect(string_io.string).to match(%(caf��!))
+    end
+
+    after do
+      described_class.default_options = { bodies: false }
+    end
+  end
+
+  context 'when logging errors' do
+    let(:logger_options) { { errors: true } }
+
+    it 'logs error message' do
+      expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+      expect(string_io.string).to match(%(no stubbed request for get http:/noroute))
+    end
+  end
+
+  context 'when logging headers and errors' do
+    let(:logger_options) { { headers: true, errors: true } }
+
+    it 'logs error message' do
+      expect { conn.get '/connection_failed' }.to raise_error(Faraday::ConnectionFailed)
+      expect(string_io.string).to match(%(Failed to open TCP connection))
+    end
+  end
+
   context 'when using log_level' do
     let(:logger_options) { { bodies: true, log_level: :debug } }
 

data/spec/faraday/response/raise_error_spec.rb

@@ -11,8 +11,10 @@ RSpec.describe Faraday::Response::RaiseError do
         stub.get('forbidden') { [403, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('proxy-error') { [407, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('request-timeout') { [408, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('conflict') { [409, { 'X-Reason' => 'because' }, 'keep looking'] }
-        stub.get('unprocessable-entity') { [422, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('unprocessable-content') { [422, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('too-many-requests') { [429, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('4xx') { [499, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('nil-status') { [nil, { 'X-Reason' => 'nil' }, 'fail'] }
         stub.get('server-error') { [500, { 'X-Error' => 'bailout' }, 'fail'] }
@@ -26,7 +28,7 @@ RSpec.describe Faraday::Response::RaiseError do
 
   it 'raises Faraday::BadRequestError for 400 responses' do
     expect { conn.get('bad-request') }.to raise_error(Faraday::BadRequestError) do |ex|
-      expect(ex.message).to eq('the server responded with status 400')
+      expect(ex.message).to eq('the server responded with status 400 for GET http:/bad-request')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(400)
       expect(ex.response_status).to eq(400)
@@ -37,7 +39,7 @@ RSpec.describe Faraday::Response::RaiseError do
 
   it 'raises Faraday::UnauthorizedError for 401 responses' do
     expect { conn.get('unauthorized') }.to raise_error(Faraday::UnauthorizedError) do |ex|
-      expect(ex.message).to eq('the server responded with status 401')
+      expect(ex.message).to eq('the server responded with status 401 for GET http:/unauthorized')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(401)
       expect(ex.response_status).to eq(401)
@@ -48,7 +50,7 @@ RSpec.describe Faraday::Response::RaiseError do
 
   it 'raises Faraday::ForbiddenError for 403 responses' do
     expect { conn.get('forbidden') }.to raise_error(Faraday::ForbiddenError) do |ex|
-      expect(ex.message).to eq('the server responded with status 403')
+      expect(ex.message).to eq('the server responded with status 403 for GET http:/forbidden')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(403)
       expect(ex.response_status).to eq(403)
@@ -59,7 +61,7 @@ RSpec.describe Faraday::Response::RaiseError do
 
   it 'raises Faraday::ResourceNotFound for 404 responses' do
     expect { conn.get('not-found') }.to raise_error(Faraday::ResourceNotFound) do |ex|
-      expect(ex.message).to eq('the server responded with status 404')
+      expect(ex.message).to eq('the server responded with status 404 for GET http:/not-found')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(404)
       expect(ex.response_status).to eq(404)
@@ -79,9 +81,20 @@ RSpec.describe Faraday::Response::RaiseError do
     end
   end
 
+  it 'raises Faraday::RequestTimeoutError for 408 responses' do
+    expect { conn.get('request-timeout') }.to raise_error(Faraday::RequestTimeoutError) do |ex|
+      expect(ex.message).to eq('the server responded with status 408 for GET http:/request-timeout')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(408)
+      expect(ex.response_status).to eq(408)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+
   it 'raises Faraday::ConflictError for 409 responses' do
     expect { conn.get('conflict') }.to raise_error(Faraday::ConflictError) do |ex|
-      expect(ex.message).to eq('the server responded with status 409')
+      expect(ex.message).to eq('the server responded with status 409 for GET http:/conflict')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(409)
       expect(ex.response_status).to eq(409)
@@ -90,9 +103,20 @@ RSpec.describe Faraday::Response::RaiseError do
     end
   end
 
-  it 'raises Faraday::UnprocessableEntityError for 422 responses' do
-    expect { conn.get('unprocessable-entity') }.to raise_error(Faraday::UnprocessableEntityError) do |ex|
-      expect(ex.message).to eq('the server responded with status 422')
+  it 'raises legacy Faraday::UnprocessableEntityError for 422 responses' do
+    expect { conn.get('unprocessable-content') }.to raise_error(Faraday::UnprocessableEntityError) do |ex|
+      expect(ex.message).to eq('the server responded with status 422 for GET http:/unprocessable-content')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(422)
+      expect(ex.response_status).to eq(422)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+
+  it 'raises Faraday::UnprocessableContentError for 422 responses' do
+    expect { conn.get('unprocessable-content') }.to raise_error(Faraday::UnprocessableContentError) do |ex|
+      expect(ex.message).to eq('the server responded with status 422 for GET http:/unprocessable-content')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(422)
       expect(ex.response_status).to eq(422)
@@ -101,6 +125,17 @@ RSpec.describe Faraday::Response::RaiseError do
     end
   end
 
+  it 'raises Faraday::TooManyRequestsError for 429 responses' do
+    expect { conn.get('too-many-requests') }.to raise_error(Faraday::TooManyRequestsError) do |ex|
+      expect(ex.message).to eq('the server responded with status 429 for GET http:/too-many-requests')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(429)
+      expect(ex.response_status).to eq(429)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+
   it 'raises Faraday::NilStatusError for nil status in response' do
     expect { conn.get('nil-status') }.to raise_error(Faraday::NilStatusError) do |ex|
       expect(ex.message).to eq('http status could not be derived from the server response')
@@ -114,7 +149,7 @@ RSpec.describe Faraday::Response::RaiseError do
 
   it 'raises Faraday::ClientError for other 4xx responses' do
     expect { conn.get('4xx') }.to raise_error(Faraday::ClientError) do |ex|
-      expect(ex.message).to eq('the server responded with status 499')
+      expect(ex.message).to eq('the server responded with status 499 for GET http:/4xx')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(499)
       expect(ex.response_status).to eq(499)
@@ -125,7 +160,7 @@ RSpec.describe Faraday::Response::RaiseError do
 
   it 'raises Faraday::ServerError for 500 responses' do
     expect { conn.get('server-error') }.to raise_error(Faraday::ServerError) do |ex|
-      expect(ex.message).to eq('the server responded with status 500')
+      expect(ex.message).to eq('the server responded with status 500 for GET http:/server-error')
       expect(ex.response[:headers]['X-Error']).to eq('bailout')
       expect(ex.response[:status]).to eq(500)
       expect(ex.response_status).to eq(500)
@@ -137,21 +172,24 @@ RSpec.describe Faraday::Response::RaiseError do
   describe 'request info' do
     let(:conn) do
       Faraday.new do |b|
-        b.response :raise_error
+        b.response :raise_error, **middleware_options
         b.adapter :test do |stub|
-          stub.post('request?full=true', request_body, request_headers) do
+          stub.post(url, request_body, request_headers) do
             [400, { 'X-Reason' => 'because' }, 'keep looking']
           end
         end
       end
     end
+    let(:middleware_options) { {} }
     let(:request_body) { JSON.generate({ 'item' => 'sth' }) }
     let(:request_headers) { { 'Authorization' => 'Basic 123' } }
+    let(:url_path) { 'request' }
+    let(:query_params) { 'full=true' }
+    let(:url) { "#{url_path}?#{query_params}" }
 
     subject(:perform_request) do
-      conn.post 'request' do |req|
+      conn.post url do |req|
         req.headers['Authorization'] = 'Basic 123'
-        req.params[:full] = true
         req.body = request_body
       end
     end
@@ -159,11 +197,90 @@ RSpec.describe Faraday::Response::RaiseError do
     it 'returns the request info in the exception' do
       expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
         expect(ex.response[:request][:method]).to eq(:post)
-        expect(ex.response[:request][:url_path]).to eq('/request')
+        expect(ex.response[:request][:url]).to eq(URI("http:/#{url}"))
+        expect(ex.response[:request][:url_path]).to eq("/#{url_path}")
         expect(ex.response[:request][:params]).to eq({ 'full' => 'true' })
         expect(ex.response[:request][:headers]).to match(a_hash_including(request_headers))
         expect(ex.response[:request][:body]).to eq(request_body)
       end
     end
+
+    describe 'DEFAULT_OPTION: include_request' do
+      before(:each) do
+        Faraday::Response::RaiseError.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+
+      after(:all) do
+        Faraday::Response::RaiseError.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+
+      context 'when RaiseError DEFAULT_OPTION (include_request: true) is used' do
+        it 'includes request info in the exception' do
+          expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+            expect(ex.response.keys).to contain_exactly(
+              :status,
+              :headers,
+              :body,
+              :request
+            )
+          end
+        end
+      end
+
+      context 'when application sets default_options `include_request: false`' do
+        before(:each) do
+          Faraday::Response::RaiseError.default_options = { include_request: false }
+        end
+
+        context 'and when include_request option is omitted' do
+          it 'does not include request info in the exception' do
+            expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+              expect(ex.response.keys).to contain_exactly(
+                :status,
+                :headers,
+                :body
+              )
+            end
+          end
+        end
+
+        context 'and when include_request option is explicitly set for instance' do
+          let(:middleware_options) { { include_request: true } }
+
+          it 'includes request info in the exception' do
+            expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+              expect(ex.response.keys).to contain_exactly(
+                :status,
+                :headers,
+                :body,
+                :request
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe 'allowing certain status codes' do
+    let(:conn) do
+      Faraday.new do |b|
+        b.response :raise_error, allowed_statuses: [404]
+        b.adapter :test do |stub|
+          stub.get('bad-request') { [400, { 'X-Reason' => 'because' }, 'keep looking'] }
+          stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
+        end
+      end
+    end
+
+    it 'raises an error for status codes that are not explicitly allowed' do
+      expect { conn.get('bad-request') }.to raise_error(Faraday::BadRequestError)
+    end
+
+    it 'does not raise an error for allowed status codes' do
+      expect { conn.get('not-found') }.not_to raise_error
+    end
   end
 end

data/spec/faraday/response_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Faraday::Response do
   subject { Faraday::Response.new(env) }
 
   let(:env) do
-    Faraday::Env.from(status: 404, body: 'yikes',
+    Faraday::Env.from(status: 404, body: 'yikes', url: Faraday::Utils.URI('https://lostisland.github.io/faraday'),
                       response_headers: { 'Content-Type' => 'text/plain' })
   end
 
@@ -13,6 +13,7 @@ RSpec.describe Faraday::Response do
   it { expect(subject.success?).to be_falsey }
   it { expect(subject.status).to eq(404) }
   it { expect(subject.body).to eq('yikes') }
+  it { expect(subject.url).to eq(URI('https://lostisland.github.io/faraday')) }
   it { expect(subject.headers['Content-Type']).to eq('text/plain') }
   it { expect(subject['content-type']).to eq('text/plain') }
 
@@ -30,6 +31,13 @@ RSpec.describe Faraday::Response do
     it { expect(hash[:status]).to eq(subject.status) }
     it { expect(hash[:response_headers]).to eq(subject.headers) }
     it { expect(hash[:body]).to eq(subject.body) }
+    it { expect(hash[:url]).to eq(subject.env.url) }
+
+    context 'when response is not finished' do
+      subject { Faraday::Response.new.to_hash }
+
+      it { is_expected.to eq({ status: nil, body: nil, response_headers: {}, url: nil }) }
+    end
   end
 
   describe 'marshal serialization support' do
@@ -45,6 +53,7 @@ RSpec.describe Faraday::Response do
     it { expect(loaded.env[:body]).to eq(env[:body]) }
     it { expect(loaded.env[:response_headers]).to eq(env[:response_headers]) }
     it { expect(loaded.env[:status]).to eq(env[:status]) }
+    it { expect(loaded.env[:url]).to eq(env[:url]) }
   end
 
   describe '#on_complete' do

data/spec/faraday/utils/headers_spec.rb

@@ -56,27 +56,54 @@ RSpec.describe Faraday::Utils::Headers do
     it { expect(subject.delete('content-type')).to be_nil }
   end
 
-  describe '#parse' do
-    before { subject.parse(headers) }
+  describe '#dig' do
+    before { subject['Content-Type'] = 'application/json' }
+
+    it { expect(subject&.dig('Content-Type')).to eq('application/json') }
+    it { expect(subject&.dig('CONTENT-TYPE')).to eq('application/json') }
+    it { expect(subject&.dig(:content_type)).to eq('application/json') }
+    it { expect(subject&.dig('invalid')).to be_nil }
+  end
 
+  describe '#parse' do
     context 'when response headers leave http status line out' do
       let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" }
 
+      before { subject.parse(headers) }
+
       it { expect(subject.keys).to eq(%w[Content-Type]) }
       it { expect(subject['Content-Type']).to eq('text/html') }
       it { expect(subject['content-type']).to eq('text/html') }
     end
 
     context 'when response headers values include a colon' do
-      let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://sushi.com/\r\n\r\n" }
+      let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://httpbingo.org/\r\n\r\n" }
 
-      it { expect(subject['location']).to eq('http://sushi.com/') }
+      before { subject.parse(headers) }
+
+      it { expect(subject['location']).to eq('http://httpbingo.org/') }
     end
 
     context 'when response headers include a blank line' do
       let(:headers) { "HTTP/1.1 200 OK\r\n\r\nContent-Type: text/html\r\n\r\n" }
 
+      before { subject.parse(headers) }
+
       it { expect(subject['content-type']).to eq('text/html') }
     end
+
+    context 'when response headers include already stored keys' do
+      let(:headers) { "HTTP/1.1 200 OK\r\nX-Numbers: 123\r\n\r\n" }
+
+      before do
+        h = subject
+        h[:x_numbers] = 8
+        h.parse(headers)
+      end
+
+      it do
+        expect(subject[:x_numbers]).to eq('8, 123')
+      end
+    end
   end
 end

data/spec/faraday/utils_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Faraday::Utils do
   describe 'headers parsing' do
     let(:multi_response_headers) do
       "HTTP/1.x 500 OK\r\nContent-Type: text/html; charset=UTF-8\r\n" \
-      "HTTP/1.x 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n"
+        "HTTP/1.x 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n"
     end
 
     it 'parse headers for aggregated responses' do
@@ -33,7 +33,7 @@ RSpec.describe Faraday::Utils do
     end
 
     it 'parses with URI' do
-      with_default_uri_parser(::URI) do
+      with_default_uri_parser(URI) do
         uri = normalize(url)
         expect(uri.host).to eq('example.com')
       end
@@ -53,4 +53,68 @@ RSpec.describe Faraday::Utils do
       expect(headers).not_to have_key('authorization')
     end
   end
+
+  describe '.deep_merge!' do
+    let(:connection_options) { Faraday::ConnectionOptions.new }
+    let(:url) do
+      {
+        url: 'http://example.com/abc',
+        headers: { 'Mime-Version' => '1.0' },
+        request: { oauth: { consumer_key: 'anonymous' } },
+        ssl: { version: '2' }
+      }
+    end
+
+    it 'recursively merges the headers' do
+      connection_options.headers = { user_agent: 'My Agent 1.0' }
+      deep_merge = Faraday::Utils.deep_merge!(connection_options, url)
+
+      expect(deep_merge.headers).to eq('Mime-Version' => '1.0', user_agent: 'My Agent 1.0')
+    end
+
+    context 'when a target hash has an Options Struct value' do
+      let(:request) do
+        {
+          params_encoder: nil,
+          proxy: nil,
+          bind: nil,
+          timeout: nil,
+          open_timeout: nil,
+          read_timeout: nil,
+          write_timeout: nil,
+          boundary: nil,
+          oauth: { consumer_key: 'anonymous' },
+          context: nil,
+          on_data: nil
+        }
+      end
+      let(:ssl) do
+        {
+          verify: nil,
+          ca_file: nil,
+          ca_path: nil,
+          verify_mode: nil,
+          cert_store: nil,
+          client_cert: nil,
+          client_key: nil,
+          certificate: nil,
+          private_key: nil,
+          verify_depth: nil,
+          version: '2',
+          min_version: nil,
+          max_version: nil,
+          verify_hostname: nil,
+          hostname: nil,
+          ciphers: nil
+        }
+      end
+
+      it 'does not overwrite an Options Struct value' do
+        deep_merge = Faraday::Utils.deep_merge!(connection_options, url)
+
+        expect(deep_merge.request.to_h).to eq(request)
+        expect(deep_merge.ssl.to_h).to eq(ssl)
+      end
+    end
+  end
 end

data/spec/faraday_spec.rb

@@ -18,10 +18,16 @@ RSpec.describe Faraday do
     end
 
     it 'uses method_missing on Faraday if there is no proxyable method' do
-      expect { Faraday.this_method_does_not_exist }.to raise_error(
-        NoMethodError,
-        "undefined method `this_method_does_not_exist' for Faraday:Module"
-      )
+      expected_message =
+        if RUBY_VERSION >= '3.4'
+          "undefined method 'this_method_does_not_exist' for module Faraday"
+        elsif RUBY_VERSION >= '3.3'
+          "undefined method `this_method_does_not_exist' for module Faraday"
+        else
+          "undefined method `this_method_does_not_exist' for Faraday:Module"
+        end
+
+      expect { Faraday.this_method_does_not_exist }.to raise_error(NoMethodError, expected_message)
     end
 
     it 'proxied methods can be accessed' do

data/spec/spec_helper.rb

@@ -29,14 +29,15 @@ SimpleCov.start do
   minimum_coverage_by_file 26
 end
 
-# Ensure all /lib files are loaded
-# so they will be included in the test coverage report.
-Dir['./lib/**/*.rb'].sort.each { |file| require file }
-
 require 'faraday'
 require 'pry'
 
-Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+# Ensure all /lib files are loaded
+# so they will be included in the test coverage report.
+Dir['./lib/**/*.rb'].each { |file| require file }
+
+# Load all Rspec support files
+Dir['./spec/support/**/*.rb'].each { |file| require file }
 
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate

data/spec/support/fake_safe_buffer.rb

@@ -8,7 +8,7 @@ FakeSafeBuffer = Struct.new(:string) do
 
   def gsub(regex)
     string.gsub(regex) do
-      match, = $&, '' =~ /a/
+      match, = Regexp.last_match(0), '' =~ /a/ # rubocop:disable Performance/StringInclude
       yield(match)
     end
   end

data/spec/support/faraday_middleware_subclasses.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FaradayMiddlewareSubclasses
+  class SubclassNoOptions < Faraday::Middleware
+  end
+
+  class SubclassOneOption < Faraday::Middleware
+    DEFAULT_OPTIONS = { some_other_option: false }.freeze
+  end
+
+  class SubclassTwoOptions < Faraday::Middleware
+    DEFAULT_OPTIONS = { some_option: true, some_other_option: false }.freeze
+  end
+end
+
+Faraday::Response.register_middleware(no_options: FaradayMiddlewareSubclasses::SubclassNoOptions)
+Faraday::Response.register_middleware(one_option: FaradayMiddlewareSubclasses::SubclassOneOption)
+Faraday::Response.register_middleware(two_options: FaradayMiddlewareSubclasses::SubclassTwoOptions)