faraday 1.1.0 → 2.7.4

data/spec/faraday/response/json_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Response::Json, type: :response do
+  let(:options) { {} }
+  let(:headers) { {} }
+  let(:middleware) do
+    described_class.new(lambda { |env|
+      Faraday::Response.new(env)
+    }, **options)
+  end
+
+  def process(body, content_type = 'application/json', options = {})
+    env = {
+      body: body, request: options,
+      request_headers: Faraday::Utils::Headers.new,
+      response_headers: Faraday::Utils::Headers.new(headers)
+    }
+    env[:response_headers]['content-type'] = content_type if content_type
+    yield(env) if block_given?
+    middleware.call(Faraday::Env.from(env))
+  end
+
+  context 'no type matching' do
+    it "doesn't change nil body" do
+      expect(process(nil).body).to be_nil
+    end
+
+    it 'nullifies empty body' do
+      expect(process('').body).to be_nil
+    end
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to be_nil
+    end
+  end
+
+  context 'with preserving raw' do
+    let(:options) { { preserve_raw: true } }
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to eq('{"a":1}')
+    end
+  end
+
+  context 'with default regexp type matching' do
+    it 'parses json body of correct type' do
+      response = process('{"a":1}', 'application/x-json')
+      expect(response.body).to eq('a' => 1)
+    end
+
+    it 'ignores json body of incorrect type' do
+      response = process('{"a":1}', 'text/json-xml')
+      expect(response.body).to eq('{"a":1}')
+    end
+  end
+
+  context 'with array type matching' do
+    let(:options) { { content_type: %w[a/b c/d] } }
+
+    it 'parses json body of correct type' do
+      expect(process('{"a":1}', 'a/b').body).to be_a(Hash)
+      expect(process('{"a":1}', 'c/d').body).to be_a(Hash)
+    end
+
+    it 'ignores json body of incorrect type' do
+      expect(process('{"a":1}', 'a/d').body).not_to be_a(Hash)
+    end
+  end
+
+  it 'chokes on invalid json' do
+    expect { process('{!') }.to raise_error(Faraday::ParsingError)
+  end
+
+  it 'includes the response on the ParsingError instance' do
+    process('{') { |env| env[:response] = Faraday::Response.new }
+    raise 'Parsing should have failed.'
+  rescue Faraday::ParsingError => e
+    expect(e.response).to be_a(Faraday::Response)
+  end
+
+  context 'HEAD responses' do
+    it "nullifies the body if it's only one space" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+
+    it "nullifies the body if it's two spaces" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+  end
+
+  context 'JSON options' do
+    let(:body) { '{"a": 1}' }
+    let(:result) { { a: 1 } }
+    let(:options) do
+      {
+        parser_options: {
+          symbolize_names: true
+        }
+      }
+    end
+
+    it 'passes relevant options to JSON parse' do
+      expect(::JSON).to receive(:parse)
+        .with(body, options[:parser_options])
+        .and_return(result)
+
+      response = process(body)
+      expect(response.body).to eq(result)
+    end
+  end
+end

data/spec/faraday/response/logger_spec.rb

@@ -64,6 +64,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 +103,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))
@@ -188,6 +207,15 @@ RSpec.describe Faraday::Response::Logger do
     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 using log_level' do
     let(:logger_options) { { bodies: true, log_level: :debug } }
 

data/spec/faraday/response/raise_error_spec.rb

@@ -29,6 +29,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 400')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(400)
+      expect(ex.response_status).to eq(400)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -37,6 +40,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 401')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(401)
+      expect(ex.response_status).to eq(401)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -45,6 +51,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 403')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(403)
+      expect(ex.response_status).to eq(403)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -53,6 +62,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 404')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(404)
+      expect(ex.response_status).to eq(404)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -61,6 +73,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('407 "Proxy Authentication Required"')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(407)
+      expect(ex.response_status).to eq(407)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -69,6 +84,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 409')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(409)
+      expect(ex.response_status).to eq(409)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -77,6 +95,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 422')
       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
 
@@ -85,6 +106,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('http status could not be derived from the server response')
       expect(ex.response[:headers]['X-Reason']).to eq('nil')
       expect(ex.response[:status]).to be_nil
+      expect(ex.response_status).to be_nil
+      expect(ex.response_body).to eq('fail')
+      expect(ex.response_headers['X-Reason']).to eq('nil')
     end
   end
 
@@ -93,6 +117,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 499')
       expect(ex.response[:headers]['X-Reason']).to eq('because')
       expect(ex.response[:status]).to eq(499)
+      expect(ex.response_status).to eq(499)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
     end
   end
 
@@ -101,6 +128,9 @@ RSpec.describe Faraday::Response::RaiseError do
       expect(ex.message).to eq('the server responded with status 500')
       expect(ex.response[:headers]['X-Error']).to eq('bailout')
       expect(ex.response[:status]).to eq(500)
+      expect(ex.response_status).to eq(500)
+      expect(ex.response_body).to eq('fail')
+      expect(ex.response_headers['X-Error']).to eq('bailout')
     end
   end
 
@@ -109,7 +139,7 @@ RSpec.describe Faraday::Response::RaiseError do
       Faraday.new do |b|
         b.response :raise_error
         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
@@ -117,11 +147,13 @@ RSpec.describe Faraday::Response::RaiseError do
     end
     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
@@ -129,7 +161,8 @@ 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)

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
 
@@ -30,6 +30,7 @@ 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) }
   end
 
   describe 'marshal serialization support' do
@@ -45,6 +46,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

@@ -57,26 +57,44 @@ RSpec.describe Faraday::Utils::Headers do
   end
 
   describe '#parse' do
-    before { subject.parse(headers) }
-
     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
@@ -53,4 +53,66 @@ 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
+        }
+      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/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/helper_methods.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'multipart_parser/reader'
-
 module Faraday
   module HelperMethods
     def self.included(base)
@@ -86,41 +84,6 @@ module Faraday
       end
     end
 
-    def multipart_file
-      Faraday::FilePart.new(__FILE__, 'text/x-ruby')
-    end
-
-    # parse boundary out of a Content-Type header like:
-    #   Content-Type: multipart/form-data; boundary=gc0p4Jq0M2Yt08jU534c0p
-    def parse_multipart_boundary(ctype)
-      MultipartParser::Reader.extract_boundary_value(ctype)
-    end
-
-    # parse a multipart MIME message, returning a hash of any multipart errors
-    def parse_multipart(boundary, body)
-      reader = MultipartParser::Reader.new(boundary)
-      result = { errors: [], parts: [] }
-      def result.part(name)
-        hash = self[:parts].detect { |h| h[:part].name == name }
-        [hash[:part], hash[:body].join]
-      end
-
-      reader.on_part do |part|
-        result[:parts] << thispart = {
-          part: part,
-          body: []
-        }
-        part.on_data do |chunk|
-          thispart[:body] << chunk
-        end
-      end
-      reader.on_error do |msg|
-        result[:errors] << msg
-      end
-      reader.write(body)
-      result
-    end
-
     def method_with_body?(method)
       self.class.method_with_body?(method)
     end

data/spec/support/shared_examples/adapter.rb

@@ -33,20 +33,21 @@ shared_examples 'adapter examples' do |**options|
 
   let(:protocol) { ssl_mode? ? 'https' : 'http' }
   let(:remote) { "#{protocol}://example.com" }
+  let(:stub_remote) { remote }
 
   let(:conn) do
     conn_options[:ssl] ||= {}
-    conn_options[:ssl][:ca_file] ||= ENV['SSL_FILE']
+    conn_options[:ssl][:ca_file] ||= ENV.fetch('SSL_FILE', nil)
+    conn_options[:ssl][:verify_hostname] ||= ENV['SSL_VERIFY_HOSTNAME'] == 'yes'
 
     Faraday.new(remote, conn_options) do |conn|
-      conn.request :multipart
       conn.request :url_encoded
       conn.response :raise_error
       conn.adapter described_class, *adapter_options
     end
   end
 
-  let!(:request_stub) { stub_request(http_method, remote) }
+  let!(:request_stub) { stub_request(http_method, stub_remote) }
 
   after do
     expect(request_stub).to have_been_requested unless request_stub.disabled?