faraday 2.7.10 → 2.14.1

data/lib/faraday/response/logger.rb

@@ -10,11 +10,13 @@ module Faraday
     # lifecycle to a given Logger object. By default, this logs to STDOUT. See
     # Faraday::Logging::Formatter to see specifically what is logged.
     class Logger < Middleware
+      DEFAULT_OPTIONS = { formatter: Logging::Formatter }.merge(Logging::Formatter::DEFAULT_OPTIONS).freeze
+
       def initialize(app, logger = nil, options = {})
-        super(app)
+        super(app, options)
         logger ||= ::Logger.new($stdout)
-        formatter_class = options.delete(:formatter) || Logging::Formatter
-        @formatter = formatter_class.new(logger: logger, options: options)
+        formatter_class = @options.delete(:formatter)
+        @formatter = formatter_class.new(logger: logger, options: @options)
         yield @formatter if block_given?
       end
 

data/lib/faraday/response/raise_error.rb

@@ -6,30 +6,32 @@ module Faraday
     # client or server error responses.
     class RaiseError < Middleware
       # rubocop:disable Naming/ConstantName
-      ClientErrorStatuses = (400...500).freeze
-      ServerErrorStatuses = (500...600).freeze
+      ClientErrorStatuses = (400...500)
+      ServerErrorStatuses = (500...600)
+      ClientErrorStatusesWithCustomExceptions = {
+        400 => Faraday::BadRequestError,
+        401 => Faraday::UnauthorizedError,
+        403 => Faraday::ForbiddenError,
+        404 => Faraday::ResourceNotFound,
+        408 => Faraday::RequestTimeoutError,
+        409 => Faraday::ConflictError,
+        422 => Faraday::UnprocessableContentError,
+        429 => Faraday::TooManyRequestsError
+      }.freeze
       # rubocop:enable Naming/ConstantName
 
+      DEFAULT_OPTIONS = { include_request: true, allowed_statuses: [] }.freeze
+
       def on_complete(env)
+        return if Array(options[:allowed_statuses]).include?(env[:status])
+
         case env[:status]
-        when 400
-          raise Faraday::BadRequestError, response_values(env)
-        when 401
-          raise Faraday::UnauthorizedError, response_values(env)
-        when 403
-          raise Faraday::ForbiddenError, response_values(env)
-        when 404
-          raise Faraday::ResourceNotFound, response_values(env)
+        when *ClientErrorStatusesWithCustomExceptions.keys
+          raise ClientErrorStatusesWithCustomExceptions[env[:status]], response_values(env)
         when 407
           # mimic the behavior that we get with proxy requests with HTTPS
           msg = %(407 "Proxy Authentication Required")
           raise Faraday::ProxyAuthError.new(msg, response_values(env))
-        when 408
-          raise Faraday::RequestTimeoutError, response_values(env)
-        when 409
-          raise Faraday::ConflictError, response_values(env)
-        when 422
-          raise Faraday::UnprocessableEntityError, response_values(env)
         when ClientErrorStatuses
           raise Faraday::ClientError, response_values(env)
         when ServerErrorStatuses
@@ -39,11 +41,26 @@ module Faraday
         end
       end
 
+      # Returns a hash of response data with the following keys:
+      #   - status
+      #   - headers
+      #   - body
+      #   - request
+      #
+      # The `request` key is omitted when the middleware is explicitly
+      # configured with the option `include_request: false`.
       def response_values(env)
-        {
+        response = {
           status: env.status,
           headers: env.response_headers,
-          body: env.body,
+          body: env.body
+        }
+
+        # Include the request data by default. If the middleware was explicitly
+        # configured to _not_ include request data, then omit it.
+        return response unless options[:include_request]
+
+        response.merge(
           request: {
             method: env.method,
             url: env.url,
@@ -52,7 +69,7 @@ module Faraday
             headers: env.request_headers,
             body: env.request_body
           }
-        }
+        )
       end
 
       def query_params(env)

data/lib/faraday/response.rb

@@ -33,6 +33,10 @@ module Faraday
       finished? ? env.body : nil
     end
 
+    def url
+      finished? ? env.url : nil
+    end
+
     def finished?
       !!env
     end
@@ -60,9 +64,9 @@ module Faraday
 
     def to_hash
       {
-        status: env.status, body: env.body,
-        response_headers: env.response_headers,
-        url: env.url
+        status: status, body: body,
+        response_headers: headers,
+        url: url
       }
     end
 

data/lib/faraday/utils/headers.rb

@@ -62,10 +62,10 @@ module Faraday
         super(key, val)
       end
 
-      def fetch(key, *args, &block)
+      def fetch(key, ...)
         key = KeyMap[key]
         key = @names.fetch(key.downcase, key)
-        super(key, *args, &block)
+        super(key, ...)
       end
 
       def delete(key)
@@ -77,6 +77,12 @@ module Faraday
         super(key)
       end
 
+      def dig(key, *rest)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, *rest)
+      end
+
       def include?(key)
         @names.include? key.downcase
       end

data/lib/faraday/utils.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
 require 'uri'
 require 'faraday/utils/headers'
 require 'faraday/utils/params_hash'
@@ -26,7 +25,7 @@ module Faraday
       attr_writer :default_space_encoding
     end
 
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
 
     def escape(str)
       str.to_s.gsub(ESCAPE_RE) do |match|
@@ -38,7 +37,7 @@ module Faraday
       CGI.unescape str.to_s
     end
 
-    DEFAULT_SEP = /[&;] */n.freeze
+    DEFAULT_SEP = /[&;] */n
 
     # Adapted from Rack
     def parse_query(query)
@@ -54,7 +53,7 @@ module Faraday
     end
 
     def basic_header_from(login, pass)
-      value = Base64.encode64("#{login}:#{pass}")
+      value = ["#{login}:#{pass}"].pack('m') # Base64 encoding
       value.delete!("\n")
       "Basic #{value}"
     end

data/lib/faraday/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faraday
-  VERSION = '2.7.10'
+  VERSION = '2.14.1'
 end

data/lib/faraday.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'cgi'
+require 'cgi/escape'
+require 'cgi/util' if RUBY_VERSION < '3.5'
 require 'date'
 require 'set'
 require 'forwardable'

data/spec/faraday/connection_spec.rb

@@ -300,14 +300,47 @@ RSpec.describe Faraday::Connection do
       it 'joins url to base when used relative path' do
         conn = Faraday.new(url: url)
         uri = conn.build_exclusive_url('service:search?limit=400')
-        expect(uri.to_s).to eq('http://service.com/service%3Asearch?limit=400')
+        expect(uri.to_s).to eq('http://service.com/service:search?limit=400')
       end
 
       it 'joins url to base when used with path prefix' do
         conn = Faraday.new(url: url)
         conn.path_prefix = '/api'
         uri = conn.build_exclusive_url('service:search?limit=400')
-        expect(uri.to_s).to eq('http://service.com/api/service%3Asearch?limit=400')
+        expect(uri.to_s).to eq('http://service.com/api/service:search?limit=400')
+      end
+    end
+
+    context 'with protocol-relative URL (GHSA-33mh-2634-fwr2)' do
+      it 'does not allow host override with //evil.com/path' do
+        conn.url_prefix = 'http://httpbingo.org/api'
+        uri = conn.build_exclusive_url('//evil.com/path')
+        expect(uri.host).to eq('httpbingo.org')
+      end
+
+      it 'does not allow host override with //evil.com:8080/path' do
+        conn.url_prefix = 'http://httpbingo.org/api'
+        uri = conn.build_exclusive_url('//evil.com:8080/path')
+        expect(uri.host).to eq('httpbingo.org')
+      end
+
+      it 'does not allow host override with //user:pass@evil.com/path' do
+        conn.url_prefix = 'http://httpbingo.org/api'
+        uri = conn.build_exclusive_url('//user:pass@evil.com/path')
+        expect(uri.host).to eq('httpbingo.org')
+      end
+
+      it 'does not allow host override with ///evil.com' do
+        conn.url_prefix = 'http://httpbingo.org/api'
+        uri = conn.build_exclusive_url('///evil.com')
+        expect(uri.host).to eq('httpbingo.org')
+      end
+
+      it 'still allows single-slash absolute paths' do
+        conn.url_prefix = 'http://httpbingo.org/api'
+        uri = conn.build_exclusive_url('/safe/path')
+        expect(uri.host).to eq('httpbingo.org')
+        expect(uri.path).to eq('/safe/path')
       end
     end
 

data/spec/faraday/error_spec.rb

@@ -23,8 +23,12 @@ RSpec.describe Faraday::Error do
 
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(exception) }
-      it { expect(subject.message).to eq('the server responded with status 400') }
-      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
+      it { expect(subject.message).to eq('the server responded with status 400 - method and url are not available due to include_request: false on Faraday::Response::RaiseError middleware') }
+      if RUBY_VERSION >= '3.4'
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={status: 400}>') }
+      else
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
+      end
       it { expect(subject.response_status).to eq(400) }
       it { expect(subject.response_headers).to be_nil }
       it { expect(subject.response_body).to be_nil }
@@ -61,7 +65,11 @@ RSpec.describe Faraday::Error do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(response) }
       it { expect(subject.message).to eq('custom message') }
-      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
+      if RUBY_VERSION >= '3.4'
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={status: 400}>') }
+      else
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
+      end
       it { expect(subject.response_status).to eq(400) }
       it { expect(subject.response_headers).to be_nil }
       it { expect(subject.response_body).to be_nil }
@@ -81,5 +89,87 @@ RSpec.describe Faraday::Error do
       it { expect(subject.response_headers).to eq(headers) }
       it { expect(subject.response_body).to eq(body) }
     end
+
+    context 'with hash missing status key' do
+      let(:exception) { { body: 'error body' } }
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status  - method and url are not available due to include_request: false on Faraday::Response::RaiseError middleware') }
+    end
+
+    context 'with hash with status but missing request data' do
+      let(:exception) { { status: 404, body: 'not found' } } # missing request key
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status 404 - method and url are not available due to include_request: false on Faraday::Response::RaiseError middleware') }
+    end
+
+    context 'with hash with status and request but missing method in request' do
+      let(:exception) { { status: 404, body: 'not found', request: { url: 'http://example.com/test' } } } # missing method
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status 404 for  http://example.com/test') }
+    end
+
+    context 'with hash with status and request but missing url in request' do
+      let(:exception) { { status: 404, body: 'not found', request: { method: :get } } } # missing url
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status 404 for GET ') }
+    end
+
+    context 'with properly formed Faraday::Env' do
+      # This represents the normal case - a well-formed Faraday::Env object
+      # with all the standard properties populated as they would be during
+      # a typical HTTP request/response cycle
+      let(:exception) { Faraday::Env.new }
+
+      before do
+        exception.status = 500
+        exception.method = :post
+        exception.url = URI('https://api.example.com/users')
+        exception.request = Faraday::RequestOptions.new
+        exception.response_headers = { 'content-type' => 'application/json' }
+        exception.response_body = '{"error": "Internal server error"}'
+        exception.request_headers = { 'authorization' => 'Bearer token123' }
+        exception.request_body = '{"name": "John"}'
+      end
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status 500 for POST https://api.example.com/users') }
+    end
+
+    context 'with Faraday::Env missing status key' do
+      let(:exception) { Faraday::Env.new }
+
+      before do
+        exception[:body] = 'error body'
+        # Intentionally not setting status
+      end
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status  for  ') }
+    end
+
+    context 'with Faraday::Env with direct method and url properties' do
+      let(:exception) { Faraday::Env.new }
+
+      before do
+        exception.status = 404
+        exception.method = :get
+        exception.url = URI('http://example.com/test')
+        exception[:body] = 'not found'
+      end
+
+      it { expect(subject.wrapped_exception).to be_nil }
+      it { expect(subject.response).to eq(exception) }
+      it { expect(subject.message).to eq('the server responded with status 404 for GET http://example.com/test') }
+    end
   end
 end

data/spec/faraday/middleware_spec.rb

@@ -67,4 +67,147 @@ RSpec.describe Faraday::Middleware do
       end
     end
   end
+
+  describe '::default_options' do
+    let(:subclass_no_options) { FaradayMiddlewareSubclasses::SubclassNoOptions }
+    let(:subclass_one_option) { FaradayMiddlewareSubclasses::SubclassOneOption }
+    let(:subclass_two_options) { FaradayMiddlewareSubclasses::SubclassTwoOptions }
+
+    def build_conn(resp_middleware)
+      Faraday.new do |c|
+        c.adapter :test do |stub|
+          stub.get('/success') { [200, {}, 'ok'] }
+        end
+        c.response resp_middleware
+      end
+    end
+
+    RSpec.shared_context 'reset @default_options' do
+      before(:each) do
+        FaradayMiddlewareSubclasses::SubclassNoOptions.instance_variable_set(:@default_options, nil)
+        FaradayMiddlewareSubclasses::SubclassOneOption.instance_variable_set(:@default_options, nil)
+        FaradayMiddlewareSubclasses::SubclassTwoOptions.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+    end
+
+    after(:all) do
+      FaradayMiddlewareSubclasses::SubclassNoOptions.instance_variable_set(:@default_options, nil)
+      FaradayMiddlewareSubclasses::SubclassOneOption.instance_variable_set(:@default_options, nil)
+      FaradayMiddlewareSubclasses::SubclassTwoOptions.instance_variable_set(:@default_options, nil)
+      Faraday::Middleware.instance_variable_set(:@default_options, nil)
+    end
+
+    context 'with subclass DEFAULT_OPTIONS defined' do
+      include_context 'reset @default_options'
+
+      context 'and without application options configured' do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+
+        it 'has only subclass defaults' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(subclass_no_options.default_options).to eq(subclass_no_options::DEFAULT_OPTIONS)
+          expect(subclass_one_option.default_options).to eq(subclass_one_option::DEFAULT_OPTIONS)
+          expect(subclass_two_options.default_options).to eq(subclass_two_options::DEFAULT_OPTIONS)
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+      end
+
+      context "and with one application's options changed" do
+        let(:resp2) { build_conn(:two_options).get('/success') }
+
+        before(:each) do
+          FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options = { some_option: false }
+        end
+
+        it 'only updates default options of target subclass' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(subclass_no_options.default_options).to eq(subclass_no_options::DEFAULT_OPTIONS)
+          expect(subclass_one_option.default_options).to eq(subclass_one_option::DEFAULT_OPTIONS)
+          expect(subclass_two_options.default_options).to eq({ some_option: false, some_other_option: false })
+        end
+
+        it { expect(resp2.body).to eq('ok') }
+      end
+
+      context "and with two applications' options changed" do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+        let(:resp2) { build_conn(:two_options).get('/success') }
+
+        before(:each) do
+          FaradayMiddlewareSubclasses::SubclassOneOption.default_options = { some_other_option: true }
+          FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options = { some_option: false }
+        end
+
+        it 'updates subclasses and parent independent of each other' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(subclass_no_options.default_options).to eq(subclass_no_options::DEFAULT_OPTIONS)
+          expect(subclass_one_option.default_options).to eq({ some_other_option: true })
+          expect(subclass_two_options.default_options).to eq({ some_option: false, some_other_option: false })
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+        it { expect(resp2.body).to eq('ok') }
+      end
+    end
+
+    context 'with FARADAY::MIDDLEWARE DEFAULT_OPTIONS and with Subclass DEFAULT_OPTIONS' do
+      before(:each) do
+        stub_const('Faraday::Middleware::DEFAULT_OPTIONS', { its_magic: false })
+      end
+
+      # Must stub Faraday::Middleware::DEFAULT_OPTIONS before resetting default options
+      include_context 'reset @default_options'
+
+      context 'and without application options configured' do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+
+        it 'has only subclass defaults' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(FaradayMiddlewareSubclasses::SubclassNoOptions.default_options).to eq({ its_magic: false })
+          expect(FaradayMiddlewareSubclasses::SubclassOneOption.default_options).to eq({ its_magic: false, some_other_option: false })
+          expect(FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options).to eq({ its_magic: false, some_option: true, some_other_option: false })
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+      end
+
+      context "and with two applications' options changed" do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+        let(:resp2) { build_conn(:two_options).get('/success') }
+
+        before(:each) do
+          FaradayMiddlewareSubclasses::SubclassOneOption.default_options = { some_other_option: true }
+          FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options = { some_option: false }
+        end
+
+        it 'updates subclasses and parent independent of each other' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(FaradayMiddlewareSubclasses::SubclassNoOptions.default_options).to eq({ its_magic: false })
+          expect(FaradayMiddlewareSubclasses::SubclassOneOption.default_options).to eq({ its_magic: false, some_other_option: true })
+          expect(FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options).to eq({ its_magic: false, some_option: false, some_other_option: false })
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+        it { expect(resp2.body).to eq('ok') }
+      end
+    end
+
+    describe 'default_options input validation' do
+      include_context 'reset @default_options'
+
+      it 'raises error if Faraday::Middleware option does not exist' do
+        expect { Faraday::Middleware.default_options = { something_special: true } }.to raise_error(Faraday::InitializationError) do |e|
+          expect(e.message).to eq('Invalid options provided. Keys not found in Faraday::Middleware::DEFAULT_OPTIONS: something_special')
+        end
+      end
+
+      it 'raises error if subclass option does not exist' do
+        expect { subclass_one_option.default_options = { this_is_a_typo: true } }.to raise_error(Faraday::InitializationError) do |e|
+          expect(e.message).to eq('Invalid options provided. Keys not found in FaradayMiddlewareSubclasses::SubclassOneOption::DEFAULT_OPTIONS: this_is_a_typo')
+        end
+      end
+    end
+  end
 end

data/spec/faraday/options/proxy_options_spec.rb

@@ -27,6 +27,33 @@ RSpec.describe Faraday::ProxyOptions do
       expect(options.inspect).to eq('#<Faraday::ProxyOptions (empty)>')
     end
 
+    it 'works with hash' do
+      hash = { user: 'user', password: 'pass', uri: 'http://@example.org' }
+      options = Faraday::ProxyOptions.from(hash)
+      expect(options.user).to eq('user')
+      expect(options.password).to eq('pass')
+      expect(options.uri).to be_a_kind_of(URI)
+      expect(options.path).to eq('')
+      expect(options.port).to eq(80)
+      expect(options.host).to eq('example.org')
+      expect(options.scheme).to eq('http')
+      expect(options.inspect).to match('#<Faraday::ProxyOptions uri=')
+    end
+
+    it 'works with option' do
+      opt_arg = { user: 'user', password: 'pass', uri: 'http://@example.org' }
+      option = Faraday::ConnectionOptions.from(proxy: opt_arg)
+      options = Faraday::ProxyOptions.from(option.proxy)
+      expect(options.user).to eq('user')
+      expect(options.password).to eq('pass')
+      expect(options.uri).to be_a_kind_of(URI)
+      expect(options.path).to eq('')
+      expect(options.port).to eq(80)
+      expect(options.host).to eq('example.org')
+      expect(options.scheme).to eq('http')
+      expect(options.inspect).to match('#<Faraday::ProxyOptions uri=')
+    end
+
     it 'works with no auth' do
       proxy = Faraday::ProxyOptions.from 'http://example.org'
       expect(proxy.user).to be_nil

data/spec/faraday/params_encoders/nested_spec.rb

@@ -62,7 +62,8 @@ RSpec.describe Faraday::NestedParamsEncoder do
   it 'encodes rack compat' do
     params   = { a: [{ one: '1', two: '2' }, '3', ''] }
     result   = Faraday::Utils.unescape(Faraday::NestedParamsEncoder.encode(params)).split('&')
-    expected = Rack::Utils.build_nested_query(params).split('&')
+    escaped = Rack::Utils.build_nested_query(params)
+    expected = Rack::Utils.unescape(escaped).split('&')
     expect(result).to match_array(expected)
   end
 

data/spec/faraday/request/json_spec.rb

@@ -132,4 +132,68 @@ RSpec.describe Faraday::Request::Json do
       expect(result_type).to eq('application/xml; charset=utf-8')
     end
   end
+
+  context 'with encoder' do
+    let(:encoder) do
+      double('Encoder').tap do |e|
+        allow(e).to receive(:dump) { |s, opts| JSON.generate(s, opts) }
+      end
+    end
+
+    let(:result) { process(a: 1) }
+
+    context 'when encoder is passed as object' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: encoder }) }
+
+      it 'calls specified JSON encoder\'s dump method' do
+        expect(encoder).to receive(:dump).with({ a: 1 })
+
+        result
+      end
+
+      it 'encodes body' do
+        expect(result_body).to eq('{"a":1}')
+      end
+
+      it 'adds content type' do
+        expect(result_type).to eq('application/json')
+      end
+    end
+
+    context 'when encoder is passed as an object-method pair' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: [encoder, :dump] }) }
+
+      it 'calls specified JSON encoder' do
+        expect(encoder).to receive(:dump).with({ a: 1 })
+
+        result
+      end
+
+      it 'encodes body' do
+        expect(result_body).to eq('{"a":1}')
+      end
+
+      it 'adds content type' do
+        expect(result_type).to eq('application/json')
+      end
+    end
+
+    context 'when encoder is not passed' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }) }
+
+      it 'calls JSON.generate' do
+        expect(JSON).to receive(:generate).with({ a: 1 })
+
+        result
+      end
+
+      it 'encodes body' do
+        expect(result_body).to eq('{"a":1}')
+      end
+
+      it 'adds content type' do
+        expect(result_type).to eq('application/json')
+      end
+    end
+  end
 end