faraday 1.10.3 → 2.0.0.alpha.pre.1

data/spec/faraday/request/multipart_spec.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::Multipart do
+  let(:options) { {} }
+  let(:conn) do
+    Faraday.new do |b|
+      b.request :multipart, options
+      b.request :url_encoded
+      b.adapter :test do |stub|
+        stub.post('/echo') do |env|
+          posted_as = env[:request_headers]['Content-Type']
+          expect(env[:body]).to be_a_kind_of(Faraday::CompositeReadIO)
+          [200, { 'Content-Type' => posted_as }, env[:body].read]
+        end
+      end
+    end
+  end
+
+  shared_examples 'a multipart request' do
+    it 'generates a unique boundary for each request' do
+      response1 = conn.post('/echo', payload)
+      response2 = conn.post('/echo', payload)
+
+      b1 = parse_multipart_boundary(response1.headers['Content-Type'])
+      b2 = parse_multipart_boundary(response2.headers['Content-Type'])
+      expect(b1).to_not eq(b2)
+    end
+  end
+
+  context 'FilePart: when multipart objects in param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: {
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby', nil,
+                                   'Content-Disposition' => 'form-data; foo=1'),
+          d: 2
+        }
+      }
+    end
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'FilePart: when providing json and IO content in the same payload' do
+    let(:io) { StringIO.new('io-content') }
+    let(:json) do
+      {
+        b: 1,
+        c: 2
+      }.to_json
+    end
+
+    let(:payload) do
+      {
+        json: Faraday::ParamPart.new(json, 'application/json'),
+        io: Faraday::FilePart.new(io, 'application/pdf')
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_json, body_json = result.part('json')
+      expect(part_json).to_not be_nil
+      expect(part_json.mime).to eq('application/json')
+      expect(part_json.filename).to be_nil
+      expect(body_json).to eq(json)
+
+      part_io, body_io = result.part('io')
+      expect(part_io).to_not be_nil
+      expect(part_io.mime).to eq('application/pdf')
+      expect(part_io.filename).to eq('local.path')
+      expect(body_io).to eq(io.string)
+    end
+  end
+
+  context 'FilePart: when multipart objects in array param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: [{
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby'),
+          d: 2
+        }]
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[][c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[][d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'UploadIO: when multipart objects in param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: {
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby', nil,
+                                   'Content-Disposition' => 'form-data; foo=1'),
+          d: 2
+        }
+      }
+    end
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'UploadIO: when providing json and IO content in the same payload' do
+    let(:io) { StringIO.new('io-content') }
+    let(:json) do
+      {
+        b: 1,
+        c: 2
+      }.to_json
+    end
+
+    let(:payload) do
+      {
+        json: Faraday::ParamPart.new(json, 'application/json'),
+        io: Faraday::FilePart.new(io, 'application/pdf')
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_json, body_json = result.part('json')
+      expect(part_json).to_not be_nil
+      expect(part_json.mime).to eq('application/json')
+      expect(part_json.filename).to be_nil
+      expect(body_json).to eq(json)
+
+      part_io, body_io = result.part('io')
+      expect(part_io).to_not be_nil
+      expect(part_io.mime).to eq('application/pdf')
+      expect(part_io.filename).to eq('local.path')
+      expect(body_io).to eq(io.string)
+    end
+  end
+
+  context 'UploadIO: when multipart objects in array param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: [{
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby'),
+          d: 2
+        }]
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[][c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[][d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'when passing flat_encode=true option' do
+    let(:options) { { flat_encode: true } }
+    let(:io) { StringIO.new('io-content') }
+    let(:payload) do
+      {
+        a: 1,
+        b: [
+          Faraday::FilePart.new(io, 'application/pdf'),
+          Faraday::FilePart.new(io, 'application/pdf')
+        ]
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'encode params using flat encoder' do
+      response = conn.post('/echo', payload)
+
+      expect(response.body).to include('name="b"')
+      expect(response.body).not_to include('name="b[]"')
+    end
+  end
+end

data/spec/faraday/request/retry_spec.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::Retry do
+  let(:calls) { [] }
+  let(:times_called) { calls.size }
+  let(:options) { [] }
+  let(:conn) do
+    Faraday.new do |b|
+      b.request :retry, *options
+
+      b.adapter :test do |stub|
+        %w[get post].each do |method|
+          stub.send(method, '/unstable') do |env|
+            calls << env.dup
+            env[:body] = nil # simulate blanking out response body
+            callback.call
+          end
+        end
+      end
+    end
+  end
+
+  context 'when an unexpected error happens' do
+    let(:callback) { -> { raise 'boom!' } }
+
+    before { expect { conn.get('/unstable') }.to raise_error(RuntimeError) }
+
+    it { expect(times_called).to eq(1) }
+
+    context 'and this is passed as a custom exception' do
+      let(:options) { [{ exceptions: StandardError }] }
+
+      it { expect(times_called).to eq(3) }
+    end
+
+    context 'and this is passed as a string custom exception' do
+      let(:options) { [{ exceptions: 'StandardError' }] }
+
+      it { expect(times_called).to eq(3) }
+    end
+
+    context 'and a non-existent string custom exception is passed' do
+      let(:options) { [{ exceptions: 'WrongStandardErrorNotExisting' }] }
+
+      it { expect(times_called).to eq(1) }
+    end
+  end
+
+  context 'when an expected error happens' do
+    let(:callback) { -> { raise Errno::ETIMEDOUT } }
+
+    before do
+      @started = Time.now
+      expect { conn.get('/unstable') }.to raise_error(Errno::ETIMEDOUT)
+    end
+
+    it { expect(times_called).to eq(3) }
+
+    context 'and legacy max_retry set to 1' do
+      let(:options) { [1] }
+
+      it { expect(times_called).to eq(2) }
+    end
+
+    context 'and legacy max_retry set to -9' do
+      let(:options) { [-9] }
+
+      it { expect(times_called).to eq(1) }
+    end
+
+    context 'and new max_retry set to 3' do
+      let(:options) { [{ max: 3 }] }
+
+      it { expect(times_called).to eq(4) }
+    end
+
+    context 'and new max_retry set to -9' do
+      let(:options) { [{ max: -9 }] }
+
+      it { expect(times_called).to eq(1) }
+    end
+
+    context 'and both max_retry and interval are set' do
+      let(:options) { [{ max: 2, interval: 0.1 }] }
+
+      it { expect(Time.now - @started).to be_within(0.04).of(0.2) }
+    end
+  end
+
+  context 'when no exception raised' do
+    let(:options) { [{ max: 1, retry_statuses: 429 }] }
+
+    before { conn.get('/unstable') }
+
+    context 'and response code is in retry_statuses' do
+      let(:callback) { -> { [429, {}, ''] } }
+
+      it { expect(times_called).to eq(2) }
+    end
+
+    context 'and response code is not in retry_statuses' do
+      let(:callback) { -> { [503, {}, ''] } }
+
+      it { expect(times_called).to eq(1) }
+    end
+  end
+
+  describe '#calculate_retry_interval' do
+    context 'with exponential backoff' do
+      let(:options) { { max: 5, interval: 0.1, backoff_factor: 2 } }
+      let(:middleware) { Faraday::Request::Retry.new(nil, options) }
+
+      it { expect(middleware.send(:calculate_retry_interval, 5)).to eq(0.1) }
+      it { expect(middleware.send(:calculate_retry_interval, 4)).to eq(0.2) }
+      it { expect(middleware.send(:calculate_retry_interval, 3)).to eq(0.4) }
+    end
+
+    context 'with exponential backoff and max_interval' do
+      let(:options) { { max: 5, interval: 0.1, backoff_factor: 2, max_interval: 0.3 } }
+      let(:middleware) { Faraday::Request::Retry.new(nil, options) }
+
+      it { expect(middleware.send(:calculate_retry_interval, 5)).to eq(0.1) }
+      it { expect(middleware.send(:calculate_retry_interval, 4)).to eq(0.2) }
+      it { expect(middleware.send(:calculate_retry_interval, 3)).to eq(0.3) }
+      it { expect(middleware.send(:calculate_retry_interval, 2)).to eq(0.3) }
+    end
+
+    context 'with exponential backoff and interval_randomness' do
+      let(:options) { { max: 2, interval: 0.1, interval_randomness: 0.05 } }
+      let(:middleware) { Faraday::Request::Retry.new(nil, options) }
+
+      it { expect(middleware.send(:calculate_retry_interval, 2)).to be_between(0.1, 0.105) }
+    end
+  end
+
+  context 'when method is not idempotent' do
+    let(:callback) { -> { raise Errno::ETIMEDOUT } }
+
+    before { expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT) }
+
+    it { expect(times_called).to eq(1) }
+  end
+
+  describe 'retry_if option' do
+    let(:callback) { -> { raise Errno::ETIMEDOUT } }
+    let(:options) { [{ retry_if: @check }] }
+
+    it 'retries if retry_if block always returns true' do
+      body = { foo: :bar }
+      @check = ->(_, _) { true }
+      expect { conn.post('/unstable', body) }.to raise_error(Errno::ETIMEDOUT)
+      expect(times_called).to eq(3)
+      expect(calls.all? { |env| env[:body] == body }).to be_truthy
+    end
+
+    it 'does not retry if retry_if block returns false checking env' do
+      @check = ->(env, _) { env[:method] != :post }
+      expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT)
+      expect(times_called).to eq(1)
+    end
+
+    it 'does not retry if retry_if block returns false checking exception' do
+      @check = ->(_, exception) { !exception.is_a?(Errno::ETIMEDOUT) }
+      expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT)
+      expect(times_called).to eq(1)
+    end
+
+    it 'FilePart: should rewind files on retry' do
+      io = StringIO.new('Test data')
+      filepart = Faraday::FilePart.new(io, 'application/octet/stream')
+
+      rewound = 0
+      rewind = -> { rewound += 1 }
+
+      @check = ->(_, _) { true }
+      allow(filepart).to receive(:rewind, &rewind)
+      expect { conn.post('/unstable', file: filepart) }.to raise_error(Errno::ETIMEDOUT)
+      expect(times_called).to eq(3)
+      expect(rewound).to eq(2)
+    end
+
+    it 'UploadIO: should rewind files on retry' do
+      io = StringIO.new('Test data')
+      upload_io = Faraday::FilePart.new(io, 'application/octet/stream')
+
+      rewound = 0
+      rewind = -> { rewound += 1 }
+
+      @check = ->(_, _) { true }
+      allow(upload_io).to receive(:rewind, &rewind)
+      expect { conn.post('/unstable', file: upload_io) }.to raise_error(Errno::ETIMEDOUT)
+      expect(times_called).to eq(3)
+      expect(rewound).to eq(2)
+    end
+
+    context 'when explicitly specifying methods to retry' do
+      let(:options) { [{ retry_if: @check, methods: [:post] }] }
+
+      it 'does not call retry_if for specified methods' do
+        @check = ->(_, _) { raise 'this should have never been called' }
+        expect { conn.post('/unstable') }.to raise_error(Errno::ETIMEDOUT)
+        expect(times_called).to eq(3)
+      end
+    end
+
+    context 'with empty list of methods to retry' do
+      let(:options) { [{ retry_if: @check, methods: [] }] }
+
+      it 'calls retry_if for all methods' do
+        @check = ->(_, _) { calls.size < 2 }
+        expect { conn.get('/unstable') }.to raise_error(Errno::ETIMEDOUT)
+        expect(times_called).to eq(2)
+      end
+    end
+  end
+
+  describe 'retry_after header support' do
+    let(:callback) { -> { [504, headers, ''] } }
+    let(:elapsed) { Time.now - @started }
+
+    before do
+      @started = Time.now
+      conn.get('/unstable')
+    end
+
+    context 'when retry_after bigger than interval' do
+      let(:headers) { { 'Retry-After' => '0.5' } }
+      let(:options) { [{ max: 1, interval: 0.1, retry_statuses: 504 }] }
+
+      it { expect(elapsed).to be > 0.5 }
+    end
+
+    context 'when retry_after smaller than interval' do
+      let(:headers) { { 'Retry-After' => '0.1' } }
+      let(:options) { [{ max: 1, interval: 0.2, retry_statuses: 504 }] }
+
+      it { expect(elapsed).to be > 0.2 }
+    end
+
+    context 'when retry_after is a timestamp' do
+      let(:headers) { { 'Retry-After' => (Time.now.utc + 2).strftime('%a, %d %b %Y %H:%M:%S GMT') } }
+      let(:options) { [{ max: 1, interval: 0.1, retry_statuses: 504 }] }
+
+      it { expect(elapsed).to be > 1 }
+    end
+
+    context 'when retry_after is bigger than max_interval' do
+      let(:headers) { { 'Retry-After' => (Time.now.utc + 20).strftime('%a, %d %b %Y %H:%M:%S GMT') } }
+      let(:options) { [{ max: 2, interval: 0.1, max_interval: 5, retry_statuses: 504 }] }
+
+      it { expect(times_called).to eq(1) }
+    end
+  end
+end

data/spec/faraday/request_spec.rb

@@ -22,17 +22,6 @@ RSpec.describe Faraday::Request do
     it { expect(subject.http_method).to eq(:post) }
   end
 
-  describe 'deprecate method for HTTP method' do
-    let(:http_method) { :post }
-    let(:expected_warning) do
-      %r{NOTE: Faraday::Request#method is deprecated; use http_method instead\. It will be removed in or after version 2.0 \nFaraday::Request#method called from .+/spec/faraday/request_spec.rb:\d+.}
-    end
-
-    it { expect(subject.method).to eq(:post) }
-
-    it { expect { subject.method }.to output(expected_warning).to_stderr }
-  end
-
   context 'when setting the url on setup with a URI' do
     let(:block) { proc { |req| req.url URI.parse('foo.json?a=1') } }
 

data/spec/faraday/response/json_spec.rb

@@ -76,12 +76,10 @@ RSpec.describe Faraday::Response::Json, type: :response do
   end
 
   it 'includes the response on the ParsingError instance' do
-    begin
-      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
+    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

data/spec/faraday/response/raise_error_spec.rb

@@ -139,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
@@ -147,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
@@ -159,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/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

data/spec/spec_helper.rb

@@ -38,8 +38,6 @@ require 'pry'
 
 Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
 
-Faraday::Deprecate.skip = false
-
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest

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/shared_examples/request_method.rb

@@ -79,7 +79,7 @@ shared_examples 'a request method' do |http_method|
 
   on_feature :request_body_on_query_methods do
     it 'sends request body' do
-      request_stub.with(Hash[:body, 'test'])
+      request_stub.with({ body: 'test' })
       res = if query_or_body == :body
               conn.public_send(http_method, '/', 'test')
             else
@@ -93,7 +93,7 @@ shared_examples 'a request method' do |http_method|
 
   it 'sends url encoded parameters' do
     payload = { name: 'zack' }
-    request_stub.with(Hash[query_or_body, payload])
+    request_stub.with({ query_or_body => payload })
     res = conn.public_send(http_method, '/', payload)
     if query_or_body == :query
       expect(res.env.request_body).to be_nil
@@ -104,7 +104,7 @@ shared_examples 'a request method' do |http_method|
 
   it 'sends url encoded nested parameters' do
     payload = { name: { first: 'zack' } }
-    request_stub.with(Hash[query_or_body, payload])
+    request_stub.with({ query_or_body => payload })
     conn.public_send(http_method, '/', payload)
   end
 
@@ -199,11 +199,11 @@ shared_examples 'a request method' do |http_method|
         @payload2 = { b: '2' }
 
         request_stub
-          .with(Hash[query_or_body, @payload1])
+          .with({ query_or_body => @payload1 })
           .to_return(body: @payload1.to_json)
 
         stub_request(http_method, remote)
-          .with(Hash[query_or_body, @payload2])
+          .with({ query_or_body => @payload2 })
           .to_return(body: @payload2.to_json)
 
         conn.in_parallel do